@gnar-engine/cli 1.0.0 → 1.0.1

package/bootstrap/services/user/src/services/authentication.service.js

@@ -0,0 +1,127 @@
+import { logger, db, utils } from '@gnar-engine/core';
+import { config } from '../config.js';
+
+
+/**
+ * Authentication Service
+ */
+export const auth = {
+
+    /**
+     * Create new authenticated session
+     * 
+     * @param {*} userId 
+     * @returns {string} Session token
+     */
+    createSessionToken: async (userId) => {
+      
+        try {
+            const token = utils.uuid();
+
+            const [result] = await db.execute(
+                'INSERT INTO `sessions` (`token`, `user_id`) VALUES (?, ?)',
+                [token, userId]
+            );
+
+            return token;
+        } catch (error) {
+            logger.error("Error creating session token: " + error);
+            throw error;
+        }
+    },
+    
+    /**
+     * Get authenticated user from token
+     * 
+     * @param {string} token - Session token
+     * @returns {int} User ID
+     */
+    getAuthenticatedUser: async (token) => {
+
+        try {
+            const [result] = await db.execute(
+                'SELECT * FROM `sessions` WHERE `token` = ?',
+                [token]
+            );
+
+            if (result.length === 0) {
+                return null;
+            }
+
+            const session = result[0];
+            const createdAt = new Date(session.created_at);
+            const now = new Date(); 
+            const oneHour = 60 * 60 * 1000;
+            if (now - createdAt > oneHour) {
+                return null;
+            }
+
+            return result[0].user_id;
+        } catch (error) {
+            logger.error("Error fetching authenticated user:" + error);
+            throw error;
+        }
+    },
+
+    /**
+     * Verify user credentials
+     * 
+     * @param {Object} params
+     * @param {string} params.username - Username (or email)
+     * @param {string} params.password - Password
+     * @returns {int} User ID
+     */
+    verifyCredentials: async ({username, password}) => {
+
+        const passwordHash = utils.hash(password, config.hashNameSpace);
+
+        try {
+            // try username
+            let [result] = await db.execute(
+                'SELECT * FROM `users` WHERE `username` = ? AND `password` = ?',
+                [username, passwordHash]
+            );
+
+            if (result.length > 0) {
+                return result[0].id;
+            }
+
+            // try username as email
+            [result] = await db.execute(
+                'SELECT * FROM `users` WHERE `email` = ? AND `password` = ?',
+                [username, passwordHash]
+            );
+
+            if (result.length > 0) {
+                return result[0].id;
+            }
+        } catch (error) {
+            logger.error("Error verifying credentials:" + error);
+            throw error;
+        }
+    },
+
+    /**
+     * Verify API key with username
+     * 
+     * @param {Object} params
+     * @param {string} params.apiKey - API key
+     * @param {string} params.username - Username
+     * @returns {int} User ID
+     */
+    verifyApiKey: async ({apiKey, username}) => {
+        try {
+            const [result] = await db.execute(
+                'SELECT * FROM `users` WHERE `api_key` = ? AND `username` = ?',
+                [apiKey, username]
+            );
+
+            if (result.length > 0) {
+                return result[0].id;
+            }
+        } catch (error) {
+            logger.error("Error verifying API key:" + error);
+            throw error;
+        }
+    }
+};

package/bootstrap/services/user/src/services/session.service.js

@@ -0,0 +1,58 @@
+import { logger, db, utils } from '@gnar-engine/core';
+
+
+/**
+ * Authentication Service
+ */
+export const unauthenticatedSession = {
+
+    /**
+     * Create new unauthenticated session token
+     * 
+     * @returns {string} Session token
+     */
+    createSessionToken: async () => {
+      
+        try {
+            const sessionToken = utils.uuid();
+
+            const [result] = await db.execute(
+                'INSERT INTO `unauthenticated_sessions` (`token`) VALUES (?)',
+                [sessionToken]
+            );
+
+            return sessionToken;
+        } catch (error) {
+            logger.error("Error creating unauthenticated session token: " + error);
+            throw error;
+        }
+    },
+    
+    /**
+     * Verify unauthenticated session token
+     * 
+     * @param {Object} params
+     * @param {string} params.sessionToken
+     * @returns {boolean} Session token valid
+     */
+    verifySessionToken: async ({sessionToken}) => {
+
+        try {
+            [result] = await db.execute(
+                'SELECT * FROM `unauthenticated_sessions` WHERE `token` = ?',
+                [sessionToken]
+            );
+
+            if (result.length > 0) {
+                if (result[0].expires_at > new Date()) {
+                    return true;
+                }
+            }
+
+            return false;
+        } catch (error) {
+            logger.error("Error verifying unauthenticated session token:", error);
+            throw error;
+        }
+    }
+}

package/bootstrap/services/user/src/services/user.service.js

@@ -0,0 +1,130 @@
+import { logger, db, utils } from '@gnar-engine/core';
+import { config} from '../config.js';
+
+
+/**
+ * User Service
+ */
+export const user = {
+
+    // Get all users
+    getAll: async () => {
+        try {
+            const [results, fields] = await db.execute(
+                'SELECT id, username, email, role FROM `users`'
+            );
+
+            return results;
+        } catch (error) {
+            logger.error("Error fetching users:", error);
+            throw error;
+        }
+    },
+
+    // Create a user
+    create: async ({email, role, password = null, username = null, apiKey = null}) => {
+        try {
+            const id = utils.uuid();
+            let passwordHash = null;
+
+            if (password) {
+                passwordHash = utils.hash(password, config.hashNameSpace);
+            }
+            console.log('creating user');
+            const [result] = await db.execute(
+                'INSERT INTO `users` (`id`, `email`, `password`, `username`, `role`, `api_key`) VALUES (?, ?, ?, ?, ?, ?)',
+                [id, email, passwordHash, username, role, apiKey]
+            );
+
+            const [newUser] = await db.execute(
+                'SELECT * FROM `users` WHERE `id` = ?',
+                [id]
+            );
+
+            return newUser[0];
+        } catch (error) {
+            logger.error("Error creating user:", error);
+            throw error;
+        }
+    },
+
+    // Get a user by ID
+    getById: async ({id}) => {
+        try {
+
+            const [result] = await db.execute(
+                'SELECT * FROM `users` WHERE `id` = ?',
+                [id]
+            );
+
+            if (!result || result.length === 0) {
+                return null;
+            }
+
+            return result[0];
+        } catch (error) {
+            logger.error("Error fetching user:", error);
+            throw error;
+        }
+    },
+
+    // Get a user by email
+    getByEmail: async ({email}) => {
+        try {
+            const [result] = await db.execute(
+                'SELECT * FROM `users` WHERE `email` = ?',
+                [email]
+            );
+
+            if (!result || result.length === 0) {
+                return null;
+            }
+
+            return result[0];
+        } catch (error) {
+            logger.error("Error fetching user by email:", error);
+            throw error;
+        }
+    },
+
+    // Update a user
+    update: async ({id, username, email, role}) => {
+        try {
+            const [result] = await db.execute(
+                'UPDATE `users` SET `username` = ?, `email` = ?, `role` = ? WHERE `id` = ?',
+                [username, email, role, id]
+            );
+
+            const [updatedUser] = await db.execute(
+                'SELECT * FROM `users` WHERE `id` = ?',
+                [id]
+            );
+
+            return updatedUser[0];
+        } catch (error) {
+            logger.error("Error updating user:", error);
+            throw error;
+        }
+    },
+
+    // Delete a user
+    delete: async ({id}) => {
+        try {
+            const [sessionResult] = await db.execute(
+                'DELETE FROM sessions WHERE user_id = ?',
+                [id]
+            );
+
+            const [userResult] = await db.execute(
+                'DELETE FROM `users` WHERE `id` = ?',
+                [id]
+            );
+
+            return userResult.affectedRows;
+        } catch (error) {
+            logger.error("Error deleting user:", error);
+            throw error;
+        }
+    }
+
+};

package/bootstrap/services/user/src/tests/user.test.js

@@ -0,0 +1,126 @@
+const request = require('supertest');
+const url = 'http://localhost';
+
+describe('User API', () => {
+
+    let adminAuthToken;
+    let customerAuthToken;
+    let userId;
+    let testCustomerEmail;
+
+    beforeAll(async () => {
+        // check we are not in production mode
+        if (process.env.NODE_ENV === 'production') {
+            throw new Error('Do not run tests in production mode!');
+        }
+
+        testCustomerEmail = 'customertest13@gnar.co.uk';
+    });
+
+    // Test authenticate with email and password
+    it('POST /authenticate (as admin)', async () => {
+        const response = await request(url).post('/authenticate')
+        .set('Content-Type', 'application/json')
+        .send({
+            username: 'root@gnar.co.uk',
+            password: 'gn4rlyR00tP0rt4lP4ss'
+        });
+        console.log(response.body);
+        expect(response.status).toBe(200);
+        expect(response.body).toHaveProperty('token');
+
+        adminAuthToken = response.body.token;
+    });
+
+    // Create new customer user (success no auth required)
+    it('POST /users (create new customer user no auth required)', async () => {
+        const response = await request(url).post('/users')
+        .set('Content-Type', 'application/json')
+        .send({
+            user: 
+                {
+                    email: testCustomerEmail,
+                    password: 'password1234'
+                }
+        })
+        console.log(response.body);
+        expect(response.status).toBe(200);
+        expect(response.body.users[0].email).toBe(testCustomerEmail);
+
+        // Save the new user id
+        userId = response.body.users[0].id;
+        console.log('New user id: ' + userId);
+    });
+
+    // Test authenticate with new user
+    it('POST /authenticate (as new customer user)', async () => {
+        const response = await request(url).post('/authenticate')
+        .set('Content-Type', 'application/json')
+        .send({
+            username: testCustomerEmail,
+            password: 'password1234'
+        });
+        console.log(response.body);
+        expect(response.status).toBe(200);
+        expect(response.body).toHaveProperty('token');
+
+        customerAuthToken = response.body.token;
+    });
+
+    // Fetch single customer user (as customer)
+    it('GET /users/{id} (as customer)', async () => {
+        const response = await request(url).get('/users/' + userId)
+        .set('Authorization', 'Bearer ' + customerAuthToken);
+        console.log(response.body);
+        expect(response.status).toBe(200);
+    });
+
+    // Fetch all users (not authorised as customer)
+    it('GET /users (not authorised as customer)', async () => {
+        const response = await request(url).get('/users')
+        .set('Authorization', 'Bearer ' + customerAuthToken);
+        console.log(response.body);
+        expect(response.status).toBe(403);
+    });
+
+    // Fetch all users (success as admin)
+    it('GET /users (as admin)', async () => {
+        const response = await request(url).get('/users')
+        .set('Authorization', 'Bearer ' + adminAuthToken);
+        console.log(response.body);
+        expect(response.status).toBe(200);
+    });
+
+    // Update customer user (as customer)
+    it('POST /users/{id} (as customer)', async () => {
+        const response = await request(url).post('/users/' + userId)
+        .set('Authorization', 'Bearer ' + customerAuthToken)
+        .set('Content-Type', 'application/json')
+        .send({
+            email: 'changedcustomeremail2@gnar.co.uk'
+        });
+        console.log(response.body);
+        expect(response.status).toBe(200);
+        expect(response.body.user.email).toBe('changedcustomeremail2@gnar.co.uk');
+    });
+
+    // Update customer user (check cannot elevate role to admin)
+    it('POST /users/{id} (as customer)', async () => {
+        const response = await request(url).post('/users/' + userId)
+        .set('Authorization', 'Bearer ' + customerAuthToken)
+        .set('Content-Type', 'application/json')
+        .send({
+            role: 'service_admin'
+        });
+        console.log(response.body);
+        expect(response.status).toBe(403);
+    });-
+
+    // Delete customer user (as admin)
+    it('DELETE /users/{id} (as admin)', async () => {
+        const response = await request(url).delete('/users/' + userId)
+        .set('Authorization', 'Bearer ' + adminAuthToken);
+        console.log(response.body);
+        expect(response.status).toBe(200);
+    });
+});

package/package.json

@@ -1,16 +1,12 @@
 {
     "name": "@gnar-engine/cli",
-    "version": "1.0.0",
+    "version": "1.0.1",
     "description": "Gnar Engine Development Framework CLI: Project bootstrap, scaffolder & control plane.",
     "type": "module",
     "bin": {
-        "gnar": "./dist/cli.js"
-    },
-    "main": "./dist/cli.js",
-    "files": ["dist"],
-    "scripts": {
-        "build": "esbuild src/cli.js --minify --bundle --format=esm --platform=node --outfile=dist/cli.js --packages=external"
+        "gnar": "./src/cli.js"
     },
+    "main": "./src/cli.js",
     "author": "Gnar Software Ltd.",
     "license": "MIT",
     "repository": {

package/src/agent/agent.client.js

@@ -0,0 +1,28 @@
+import client from "../services/client.js";
+
+export const agent = {
+
+    prompt: async (input, chatId) => {
+        try {
+            const response = await client.post('/agent/prompt', {
+                textInput: input,
+                chatId: chatId
+            });
+
+            if (response.status !== 200) {
+                throw new Error("Failed to prompt agent");
+            }
+
+            //console.log("Agent response: " + response.data);
+
+            return response.data;
+        } catch (error) {
+            // get response message if available
+            if (error?.response?.data?.error) {
+                return {error: error.response.data.error};
+            }
+
+            return {error: "Agent prompt failed: " + error};
+        }
+    }
+}

package/src/agent/commands.js

@@ -0,0 +1,48 @@
+// control/commands.js
+import { Command } from 'commander';
+import inquirer from 'inquirer';
+import { agent } from './agent.client.js';
+import { v4 as uuidv4 } from 'uuid';
+
+export function registerAgentCommands(program) {
+	const agentCmd = new Command('agent').description('🤖 LLM Agent Commands');
+
+	agentCmd
+		.command('session')
+		.description('🤖 Prompt the Engine Agent')
+		.action(async (options) => {
+            let chatId;
+
+			while (true) {
+				const input = await inquirer.prompt([
+					{ 
+            			type: 'text',
+						name: 'prompt',
+						message: 'Enter your prompt (or type "exit" to quit):'
+					},
+				]);
+
+				if (input.prompt.toLowerCase() === 'exit') {
+					console.log('Exiting Engine agent.');
+					break;
+				}
+
+				try {
+					const response = await agent.prompt(input.prompt, chatId);
+
+					if (response.error) {
+						console.error('❌ ' + response.error);
+					} else if (!response.structuredResponse?.responseText) {
+                        console.error('❌ Error parsing reply');
+                    } else {
+						console.log(response.structuredResponse.responseText);
+                        chatId = response.chatId;
+					}
+				} catch (error) {
+					console.error('❌ Error prompting agent:', error.message);
+				}
+			}
+		});
+
+	program.addCommand(agentCmd);
+}

package/src/cli.js

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import { registerProfileCommand } from './profiles/command.js';
+import { registerDevCommands } from './dev/commands.js';
+import { registerControlCommands } from './control/commands.js';
+import { registerScaffolderCommands } from './scaffolder/commands.js';
+import { registerAgentCommands } from './agent/commands.js';
+
+// Create a new program
+const program = new Command();
+
+// Register CLI commands
+registerDevCommands(program);
+registerProfileCommand(program);
+registerControlCommands(program);
+registerScaffolderCommands(program);
+registerAgentCommands(program);
+
+// Help
+program
+  .command('help [command]')
+  .description('❓ Display help for command');
+
+program.addHelpText('beforeAll', `
+G n a r  E n g i n e -  A powerful, AI ready microservice framework for modern applications.
+`);
+
+// Parse CLI input
+program.parse(process.argv);

package/src/config.js

@@ -0,0 +1,8 @@
+
+export const gnarEngineCliConfig = {
+
+    /**
+     * The path the Gnar Engine service core should be found in the service containers
+     */
+    corePath: '/usr/gnar_engine/app/gnarengine-service-core'
+}