@gnar-engine/cli 1.0.0 → 1.0.1

package/src/engine/infra.js

@@ -0,0 +1,142 @@
+
+import {
+  EC2Client,
+  RunInstancesCommand,
+  CreateVolumeCommand,
+  AttachVolumeCommand,
+  DescribeInstancesCommand,
+} from "@aws-sdk/client-ec2";
+import { profiles } from '../profiles/profiles.client';
+
+
+export const engineInfra = {
+
+    ec2: null,
+
+    initialiseClient: ({ availabilityZone }) => {
+        if (!engineInfra.ec2) {
+            engineInfra.ec2 = new EC2Client({ region: availabilityZone });
+        }
+
+        return engineInfra.ec2;
+    }, 
+
+    initialiseInstance: async ({ availabilityZone, instanceType, ami, size }) => {
+        try {
+            engineInfra.ec2 = await new EC2Client({
+                region: availabilityZone
+            });
+            
+            const volumeId = await engineInfra.createVolume({
+                availabilityZone,
+                size
+            });
+
+            const instanceId = await engineInfra.createInstance({
+                ami,
+                instanceType,
+                availabilityZone,
+                volumeId
+            });
+
+            profiles.setEngineInstanceId({
+                instanceId
+            });
+
+            await engineInfra.waitForInstanceRunning({
+                instanceId
+            })
+        } catch (error) {
+            console.error('Error initialising gnar engine agent instance', error);
+        }
+    },
+
+    createVolume: async ({availabilityZone, size}) => {
+        const params = {
+            AvailabilityZone: availabilityZone,
+            Size: size || 50,
+            VolumeType: "gp3",
+        };
+        const data = await engineinfra.ec2.send(new CreateVolumeCommand(params));
+        return data.VolumeId;
+    },
+
+    createInstance: async ({ami, instanceType, availabilityZone, volumeId}) => {
+        const params = {
+            ImageId: ami,
+            InstanceType: instanceType || "g5.xlarge",
+            MinCount: 1,
+            MaxCount: 1,
+            Placement: {
+                AvailabilityZone: availabilityZone
+            },
+            BlockDeviceMappings: [{
+                DeviceName: "/dev/nvme1n1", // Additional volume mount
+                Ebs: { VolumeId: volumeId, DeleteOnTermination: true },
+            }],
+            TagSpecifications: [{
+                ResourceType: "instance",
+                Tags: [{ Key: "Name", Value: "gnar-engine-agent" }],
+            }]
+        };
+
+        const data = await engineInfra.ec2.send(new RunInstancesCommand(params));
+        return data.Instances[0].InstanceId;
+    },
+
+    waitForInstanceRunning: async ({instanceId}) => {
+        while (true) {
+            const desc = await engineInfra.ec2.send(
+                new DescribeInstancesCommand({ InstanceIds: [instanceId] })
+            );
+            
+            const state = desc.Reservations[0].Instances[0].State.Name;
+            console.log(`Instance ${instanceId} is ${state}`);
+            
+            if (state === "running") {
+                console.log('Instance ready!');
+                break;
+            }
+            
+            await new Promise((r) => setTimeout(r, 5000));
+        }
+    },
+
+    startInstanceSession: async ({timeout, instanceId}) => {
+        // start instance
+        engineInfra.initialiseClient({ region });
+
+        // Start instance
+        await engineInfra.ec2.send(new StartInstancesCommand({
+            InstanceIds: [instanceId],
+        }));
+        console.log(`Instance ${instanceId} is starting...`);
+
+        // Wait for running state (reuse your existing method)
+        await engineInfra.waitForInstanceRunning({ instanceId });
+        
+        // tag instance with shutdown timestamp
+        engineInfra.tagInstanceWithShutdown({
+            timeout,
+            instanceId
+        });
+    },
+
+    tagInstanceWithShutdown: async ({timeout, instanceId}) => {
+        const now = Math.floor(Date.now() / 1000);
+        const shutdownTimestamp = now + timeout * 60;
+
+        await engineInfra.ec2.send(new CreateTagsCommand({
+            Resources: [instanceId],
+            Tags: [{
+                Key: "shutdown-timestamp",
+                Value: shutdownTimestamp.toString(),
+            }],
+        }));
+    },
+
+    addCrontabShutdownCheck: async ({instanceId}) => {
+        
+
+    }
+}

package/src/helpers/helpers.js

@@ -0,0 +1,63 @@
+
+/**
+ * CLI helper functions
+ */
+export const helpers = {
+
+    assertTrailingSlash: (path) => {
+        if (!path.endsWith('/')) {
+            return path + '/';
+        }
+        return path;
+    },
+
+    pascalCase: (str) => {
+        return str
+            .replace(/[-_\s]+(.)?/g, (_, c) => (c ? c.toUpperCase() : ''))
+            .replace(/^(.)/, (_, c) => c.toUpperCase());
+    },
+
+    pascalCasePlural: (str) => {
+        const plural = helpers.lowerCasePlural(str);
+        return helpers.pascalCase(plural);
+    },
+
+    lowerCase: (str) => {
+        return str.toLowerCase();
+    },
+
+    upperCase: (str) => {
+        return str.toUpperCase();
+    },
+
+    plural: (str) => {
+        if (str.endsWith('y')) {
+            return str.slice(0, -1).toLowerCase() + 'ies';
+        }
+        return str + 's'; 
+    },
+
+    lowerCasePlural: (str) => {
+        // A very simple pluralization. For production, use a proper pluralization lib.
+        if (str.endsWith('y')) {
+            return str.slice(0, -1).toLowerCase() + 'ies';
+        }
+        return str.toLowerCase() + 's';
+    },
+
+    capitaliseFirstLetter: (str) => {
+        if (typeof str !== 'string' || str.length === 0) {
+            return str;
+        }
+        return str.charAt(0).toUpperCase() + str.slice(1);
+    },
+
+    generateRandomString: (length) => {
+        const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+        let result = '';
+        for (let i = 0; i < length; i++) {
+            result += chars.charAt(Math.floor(Math.random() * chars.length));
+        }
+        return result;
+    }
+}

package/src/profiles/command.js

@@ -0,0 +1,170 @@
+// init/commands.js
+import { Command } from 'commander';
+import { profiles } from './profiles.client.js';
+import inquirer from 'inquirer';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+
+
+export function registerProfileCommand(program) {
+    const profile = new Command('profile').description('👤 Manage CLI profiles');
+
+    // profile get all
+    profile
+        .command('get-all')
+        .description('List all profiles')
+        .action(() => {
+            const config = profiles.getAllProfiles();
+
+            if (!config || !config.profiles || Object.keys(config.profiles).length === 0) {
+                console.error('No profiles found. Please create a profile using gnar profile create');
+                return;
+            }
+
+            Object.keys(config.profiles).forEach((p) => {
+                if (config.activeProfile == p) {
+                    console.log('- ' + p + ' (active)');
+                } else {
+                    console.log('- ' + p);
+                }
+            });
+        });
+
+    // profile get active
+    profile
+        .command('get-active')
+        .description('Show the active profile')
+        .action(() => {
+            try {
+                const {name, profile} = profiles.getActiveProfile();
+                console.log(`Active profile: ${name}`);
+            } catch (error) {
+                console.error('No active profile found. Please set one using `gnar profile set-active <profileName>`');
+            }
+        });
+
+    // profile set active <profileName>
+    profile
+        .command('set-active')
+        .description('Select active profile')
+        .action(() => {
+            try {
+                const allProfiles = profiles.getAllProfiles();
+                const choices = Object.keys(allProfiles.profiles).map((p) => {
+                    if (allProfiles.activeProfile == p) {
+                        return { name: p + ' (active)', value: p };
+                    } else {
+                        return { name: p, value: p };
+                    }
+                });
+
+                inquirer.prompt([
+                    {
+                        type: 'list',
+                        name: 'profileName',
+                        message: 'Select a profile to set as active:',
+                        choices: choices
+                    }
+                ]).then((answers) => {
+                    const profileName = answers.profileName;
+                    profiles.setActiveProfile({
+                        profileName: profileName
+                    });
+                    console.log(`✅ Profile "${profileName}" set as active.`);
+                });
+
+                return;
+            } catch (error) {
+                console.error(`❌ Error setting active profile: ${error.message}`);
+            }
+        });
+
+    // profile create
+    profile
+        .command('create')
+        .description('Create a new profile')
+        .action(async () => {
+            const answers = await inquirer.prompt([
+                { name: 'profile', message: 'Profile name', default: 'mywebsite:local'  },
+                { name: 'CLI_API_URL', message: 'API URL', default: 'http://localhost' },
+                { name: 'CLI_API_USERNAME', message: 'API Username', default: 'gnarlyroot' },
+                { name: 'CLI_API_KEY', message: 'API Key' },
+                { name: 'PROJECT_DIR', message: 'Project directory', default: process.cwd() },
+                { name: 'AWS_ACCESS_KEY_ID', message: 'AWS Access Key' },
+                { name: 'AWS_SECRET_ACCESS_KEY', message: 'AWS Secret Access Key' },
+                { name: 'AWS_REGION', message: 'AWS Region' },
+                {
+                    type: 'confirm',
+                    name: 'setActive',
+                    message: 'Set this profile as active?',
+                    default: true,
+                },
+            ]);
+
+            const profileName = answers.profile;
+            const config = {
+                CLI_API_URL: answers.CLI_API_URL,
+                CLI_API_USERNAME: answers.CLI_API_USERNAME,
+                CLI_API_KEY: answers.CLI_API_KEY,
+                PROJECT_DIR: answers.PROJECT_DIR || process.cwd(),
+                AWS_ACCESS_KEY_ID: answers.AWS_ACCESS_KEY_ID,
+                AWS_SECRET_ACCESS_KEY: answers.AWS_SECRET_ACCESS_KEY,
+                AWS_REGION: answers.AWS_REGION
+            };
+            
+            // save profile to config file
+            profiles.createProfile({ 
+                profileName: profileName,
+                config: config
+            });
+
+            // set active profile if required
+            if (answers.setActive) {
+                console.log('setting active', );
+                profiles.setActiveProfile({
+                    profileName: profileName
+                });
+            }
+        });
+
+    // update profile
+    profile
+        .command('update <profileName>')
+        .description('Update an existing profile')
+        .action(async (profileName) => {
+            const allProfiles = profiles.getAllProfiles();
+
+            if (!allProfiles.profiles[profileName]) {
+                console.error(`Profile "${profileName}" not found.`);
+                return;
+            }
+
+            const currentProfile = allProfiles.profiles[profileName];
+            const answers = await inquirer.prompt([
+                { name: 'CLI_API_URL', message: 'API URL', default: currentProfile.CLI_API_URL },
+                { name: 'CLI_API_USERNAME', message: 'API Username', default: currentProfile.CLI_API_USERNAME },
+                { name: 'CLI_API_KEY', message: 'API Key', default: currentProfile.CLI_API_KEY },
+                { name: 'PROJECT_DIR', message: 'Project directory', default: currentProfile.PROJECT_DIR || process.cwd() },
+                { name: 'AWS_ACCESS_KEY_ID', message: 'AWS Access Key', default: currentProfile.AWS_ACCESS_KEY_ID },
+                { name: 'AWS_SECRET_ACCESS_KEY', message: 'AWS Secret Access Key', default: currentProfile.AWS_SECRET_ACCESS_KEY },
+                { name: 'AWS_REGION', message: 'AWS Region', default: currentProfile.AWS_REGION }
+            ]);
+
+            // update profile
+            profiles.updateProfile({
+                profileName: profileName,
+                config: {
+                    CLI_API_URL: answers.CLI_API_URL,
+                    CLI_API_USERNAME: answers.CLI_API_USERNAME,
+                    CLI_API_KEY: answers.CLI_API_KEY,
+                    PROJECT_DIR: answers.PROJECT_DIR || process.cwd(),
+                    AWS_ACCESS_KEY_ID: answers.AWS_ACCESS_KEY_ID,
+                    AWS_SECRET_ACCESS_KEY: answers.AWS_SECRET_ACCESS_KEY,
+                    AWS_REGION: answers.AWS_REGION
+                }
+            });
+        });
+
+    program.addCommand(profile);
+}

package/src/profiles/profiles.client.js

@@ -0,0 +1,101 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+/**
+ * Gnar Engine CLI Profile Client
+ */
+export const profiles = {
+
+    configPath: path.join(os.homedir(), '.gnarengine', 'config.json'),
+
+    getAllProfiles: function (ignoreNotFound = false) {
+        if (!fs.existsSync(this.configPath)) {
+            if (!ignoreNotFound) {
+                console.error(`Config file not found at ${this.configPath}`);
+            }
+            return {};
+        }
+
+        const config = JSON.parse(fs.readFileSync(this.configPath, 'utf-8'));
+        return config || {};
+    },
+
+    getActiveProfile: function () {
+        const allProfiles = this.getAllProfiles();
+
+        if (!allProfiles || Object.keys(allProfiles).length === 0) {
+            console.error('No profiles found');
+            return null;
+        }
+
+        if (!fs.existsSync(this.configPath)) {
+            if (!ignoreNotFound) {
+                console.error(`Config file not found at ${this.configPath}`);
+            }
+            return {};
+        }
+
+        const config = JSON.parse(fs.readFileSync(this.configPath, 'utf-8'));
+        const activeProfile = config.activeProfile;
+
+        return { 
+            name: activeProfile, 
+            profile: allProfiles.profiles[activeProfile]
+        };
+    },
+
+    setActiveProfile: function ({ profileName }) {
+        if (!fs.existsSync(this.configPath)) {
+            console.error(`Config file not found at ${this.configPath}`);
+            return;
+        }
+
+        const config = JSON.parse(fs.readFileSync(this.configPath, 'utf-8'));
+        config.activeProfile = profileName;
+        fs.writeFileSync(this.configPath, JSON.stringify(config, null, 2));
+    },
+
+    createProfile: function ({ profileName, config }) {
+        if (!profileName || !config.CLI_API_URL || !config.CLI_API_USERNAME) {
+            throw new Error('Invalid profile data');
+        }
+
+        const ignoreNotFound = true;
+        const allProfiles = this.getAllProfiles(ignoreNotFound).profiles || {};
+
+        if (allProfiles[profileName]) {
+            throw new Error(`Profile "${profileName}" already exists`);
+        }
+
+        allProfiles[profileName] = config;
+
+        this.saveProfiles(allProfiles);
+        return allProfiles[profileName];
+    },
+
+    updateProfile: function ({ profileName, config }) {
+        if (!profileName || !config.CLI_API_URL || !config.CLI_API_USERNAME || !config.CLI_API_KEY) {
+            throw new Error('Invalid profile data');
+        }
+
+        const allProfiles = this.getAllProfiles().profiles || {};
+
+        if (!allProfiles[profileName]) {
+            throw new Error(`Profile "${profileName}" not found`);
+        }
+
+        allProfiles[profileName] = config;
+
+        this.saveProfiles(allProfiles);
+    },
+
+    saveProfiles: function (profilesObj) {
+        const dir = path.dirname(this.configPath);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+
+        fs.writeFileSync(this.configPath, JSON.stringify({profiles: profilesObj}, null, 2));
+    }
+};

package/src/scaffolder/commands.js

@@ -0,0 +1,123 @@
+import inquirer from 'inquirer';
+import { profiles } from '../profiles/profiles.client.js';
+import { scaffolder } from './scaffolder.handler.js';
+import path from 'path';
+
+export const registerScaffolderCommands = (program) => {
+
+    const create = program.command('create').description('📦 Scaffold new services and components');
+
+    create
+        .command('project <projectName>')
+        .description('🚀 Create a new project')
+        .action(async (projectName, options) => {
+            // validate
+            if (!projectName) {
+                console.error('❌ Please specify a project name using gnar create project <projectName>');
+                return;
+            }
+
+            // options
+            const answers = await inquirer.prompt([
+                {
+                    type: 'input',
+                    name: 'projectDir',
+                    message: 'Choose directory to create project in',
+                    default: path.join(process.cwd())
+                },
+                {
+                    type: 'input',
+                    name: 'rootAdminEmail',
+                    message: 'Root Admin Email',
+                    default: ''
+                }
+            ]);
+
+            // create the project
+            try {
+                scaffolder.createNewProject({
+                    projectName: projectName,
+                    projectDir: answers.projectDir,
+                    rootAdminEmail: answers.rootAdminEmail
+                });
+            } catch (error) {
+                console.error('❌ Error creating project:', error.message);
+            }
+        });
+
+    create
+        .command('service <service>')
+        .description('📦 Create a new service: back-end|front-end')
+        .action(async (options) => {
+            // validate
+            if (!options.service) {
+                console.error('❌ Please specify a service name using gnar create service <serviceName>');
+            }
+
+            let activeProfile;
+            try {
+                activeProfile = profiles.getActiveProfile();
+            } catch (error) {
+                console.error('❌ No active profile found. Please create or set one using `gnar profile create` or `gnar profile set-active <profileName>`');
+                return;
+            }
+
+            // prompt for service details
+            const serviceTypeAnswer = await inquirer.prompt([
+                {
+                    type: 'list',
+                    name: 'serviceType',
+                    message: 'Service Type',
+                    choices: [
+                        { name: 'Back-End', value: 'backend' },
+                        { name: 'Front-End', value: 'frontend' }
+                    ],
+                    default: 'backend'
+                }
+            ]);
+
+            // back-end service
+            if (serviceTypeAnswer.serviceType === 'backend') {
+                const backendAnswers = await inquirer.prompt([
+                    { 
+                        type: 'list',
+                        name: 'database',
+                        message: 'Database',
+                        choices: [
+                            { name: 'MYSQL', value: 'mysql' },
+                            { name: 'Mongo DB', value: 'mongodb' }
+                        ],
+                        default: 'mongodb'
+                    }
+                ]);
+
+                // create the service
+                try {
+                    console.log('Creating new service in... ' + activeProfile.profile.PROJECT_DIR);
+
+                    scaffolder.createNewService({
+                        serviceName: options.service,
+                        database: backendAnswers.database,
+                        projectDir: activeProfile.profile.PROJECT_DIR
+                    });
+
+                } catch (error) {
+                    console.error('❌ Error creating service:', error.message);
+                }
+            }
+
+            // front-end service
+            else {
+                try {
+                    console.log('Creating new service in... ' + activeProfile.profile.PROJECT_DIR);
+
+                    scaffolder.createNewFrontEndService({
+                        serviceName: options.service,
+                        projectDir: activeProfile.profile.PROJECT_DIR
+                    });
+                } catch (error) {
+                    console.error('❌ Error creating service:', error.message);
+                }
+            }
+        });
+}