stigmergy 1.0.95 → 1.0.97

package/README.md

@@ -95,6 +95,26 @@ stigmergy call qwen "translate to English"
 stigmergy call copilot "suggest improvements"
 ```
 
+### User Authentication
+
+Stigmergy CLI now supports user authentication to protect your AI tools and configurations:
+
+```bash
+# Register a new account
+stigmergy register <username> <password>
+
+# Log in to your account
+stigmergy login <username> <password>
+
+# Check authentication status
+stigmergy auth-status
+
+# Log out of your account
+stigmergy logout
+```
+
+Protected commands (like `call`, `setup`, `deploy`, `install`) require authentication before use.
+
 ### Installation Workflow
 
 1. **Scan**: `stigmergy scan` - Detects installed AI CLI tools

package/bin/stigmergy

@@ -6,6 +6,17 @@
 const path = require('path');
 const { spawn } = require('child_process');
 
+// Set up global error handlers for the launcher
+process.on('unhandledRejection', (reason, promise) => {
+  console.error('[FATAL] Launcher Unhandled Rejection at:', promise, 'reason:', reason);
+  process.exit(1);
+});
+
+process.on('uncaughtException', (error) => {
+  console.error('[FATAL] Launcher Uncaught Exception:', error);
+  process.exit(1);
+});
+
 // Get the path to the main script
 const mainScript = path.join(__dirname, '..', 'src', 'main_english.js');
 

package/docs/http-request-handler.md

@@ -0,0 +1,289 @@
+# HTTP Request Handler Documentation
+
+This document provides comprehensive documentation for the HTTP request handling functionality implemented in the Stigmergy CLI system.
+
+## Overview
+
+The HTTP request handler is implemented as a `RestClient` class that provides a simple interface for making HTTP requests to REST APIs. It supports common HTTP methods (GET, POST, PUT, PATCH, DELETE) and includes features for handling headers, query parameters, and request bodies.
+
+## Class: RestClient
+
+### Constructor
+
+```javascript
+new RestClient(baseURL, defaultHeaders)
+```
+
+Creates a new REST client instance.
+
+**Parameters:**
+- `baseURL` (string): The base URL for all API requests. Defaults to an empty string.
+- `defaultHeaders` (Object): Default headers to include in all requests. Defaults to `{ 'Content-Type': 'application/json' }`.
+
+**Example:**
+```javascript
+const client = new RestClient('https://api.example.com');
+const clientWithHeaders = new RestClient('https://api.example.com', {
+  'Authorization': 'Bearer token',
+  'User-Agent': 'MyApp/1.0'
+});
+```
+
+### Methods
+
+#### request()
+
+```javascript
+async request(method, url, options)
+```
+
+Makes an HTTP request with the specified method and options.
+
+**Parameters:**
+- `method` (string): HTTP method (GET, POST, PUT, PATCH, DELETE, etc.)
+- `url` (string): Request URL (will be appended to baseURL)
+- `options` (Object): Request options
+  - `headers` (Object): Additional headers for this request
+  - `body` (Object|string): Request body data
+  - `params` (Object): Query parameters to append to the URL
+  - `timeout` (number): Request timeout in milliseconds (default: 10000)
+
+**Returns:**
+Promise that resolves to an object with the following properties:
+- `status` (number): HTTP status code
+- `statusText` (string): HTTP status text
+- `headers` (Object): Response headers
+- `data` (Object|string): Response data (parsed as JSON if possible, otherwise as text)
+
+**Throws:**
+Error if the request fails or receives a non-2xx response.
+
+**Example:**
+```javascript
+const response = await client.request('GET', '/users', {
+  params: { page: 1, limit: 10 },
+  headers: { 'X-Custom-Header': 'value' }
+});
+console.log(response.data);
+```
+
+#### get()
+
+```javascript
+async get(url, options)
+```
+
+Makes a GET request.
+
+**Parameters:**
+- `url` (string): Request URL
+- `options` (Object): Request options (same as in `request()`)
+
+**Returns:**
+Promise that resolves to the response object.
+
+**Example:**
+```javascript
+const users = await client.get('/users', { params: { active: true } });
+```
+
+#### post()
+
+```javascript
+async post(url, data, options)
+```
+
+Makes a POST request.
+
+**Parameters:**
+- `url` (string): Request URL
+- `data` (Object): Data to send in request body
+- `options` (Object): Request options (same as in `request()`)
+
+**Returns:**
+Promise that resolves to the response object.
+
+**Example:**
+```javascript
+const newUser = await client.post('/users', {
+  name: 'John Doe',
+  email: 'john@example.com'
+});
+```
+
+#### put()
+
+```javascript
+async put(url, data, options)
+```
+
+Makes a PUT request.
+
+**Parameters:**
+- `url` (string): Request URL
+- `data` (Object): Data to send in request body
+- `options` (Object): Request options (same as in `request()`)
+
+**Returns:**
+Promise that resolves to the response object.
+
+**Example:**
+```javascript
+const updatedUser = await client.put('/users/123', {
+  name: 'Jane Doe',
+  email: 'jane@example.com'
+});
+```
+
+#### patch()
+
+```javascript
+async patch(url, data, options)
+```
+
+Makes a PATCH request.
+
+**Parameters:**
+- `url` (string): Request URL
+- `data` (Object): Data to send in request body
+- `options` (Object): Request options (same as in `request()`)
+
+**Returns:**
+Promise that resolves to the response object.
+
+**Example:**
+```javascript
+const partialUpdate = await client.patch('/users/123', {
+  lastLogin: new Date().toISOString()
+});
+```
+
+#### delete()
+
+```javascript
+async delete(url, options)
+```
+
+Makes a DELETE request.
+
+**Parameters:**
+- `url` (string): Request URL
+- `options` (Object): Request options (same as in `request()`)
+
+**Returns:**
+Promise that resolves to the response object.
+
+**Example:**
+```javascript
+await client.delete('/users/123');
+```
+
+#### setDefaultHeaders()
+
+```javascript
+setDefaultHeaders(headers)
+```
+
+Sets default headers to be included in all requests.
+
+**Parameters:**
+- `headers` (Object): Headers to set as default
+
+**Example:**
+```javascript
+client.setDefaultHeaders({
+  'Authorization': 'Bearer token',
+  'X-API-Key': 'secret-key'
+});
+```
+
+#### setAuthorization()
+
+```javascript
+setAuthorization(token, type)
+```
+
+Sets the Authorization header for all requests.
+
+**Parameters:**
+- `token` (string): Authorization token
+- `type` (string): Authorization type (default: 'Bearer')
+
+**Example:**
+```javascript
+client.setAuthorization('my-secret-token');
+client.setAuthorization('username:password', 'Basic');
+```
+
+## Usage Examples
+
+### Basic GET Request
+
+```javascript
+const RestClient = require('./src/core/rest_client');
+
+const client = new RestClient('https://jsonplaceholder.typicode.com');
+
+// Get a list of posts
+const posts = await client.get('/posts', { params: { _limit: 5 } });
+console.log(posts.data);
+```
+
+### Creating a Resource
+
+```javascript
+const newPost = {
+  title: 'My New Post',
+  body: 'This is the content',
+  userId: 1
+};
+
+const createdPost = await client.post('/posts', newPost);
+console.log('Created post with ID:', createdPost.data.id);
+```
+
+### Using Authentication
+
+```javascript
+// Set authorization header
+client.setAuthorization('your-api-token-here');
+
+// All subsequent requests will include the authorization header
+const protectedData = await client.get('/protected-resource');
+```
+
+### Custom Headers
+
+```javascript
+const client = new RestClient('https://api.example.com', {
+  'X-Custom-Header': 'custom-value',
+  'User-Agent': 'MyApp/1.0'
+});
+
+const response = await client.get('/data');
+```
+
+## Error Handling
+
+All methods will throw an Error if:
+1. The HTTP request fails (network error, timeout, etc.)
+2. The server responds with a non-2xx status code
+
+Errors can be caught using try/catch blocks:
+
+```javascript
+try {
+  const response = await client.get('/users');
+  console.log(response.data);
+} catch (error) {
+  console.error('Request failed:', error.message);
+  // Handle error appropriately
+}
+```
+
+## Notes
+
+1. The client automatically serializes JavaScript objects to JSON for request bodies when using POST, PUT, PATCH, or DELETE methods.
+2. Response data is automatically parsed as JSON if the response has a `Content-Type` of `application/json`; otherwise, it's returned as text.
+3. Query parameters are properly encoded using `URLSearchParams`.
+4. Default timeout is 10 seconds but can be customized per request.

package/docs/json-parser.md

@@ -0,0 +1,102 @@
+# JSON Parser and Validator
+
+This module provides a robust JSON parsing and validation utility function that can validate JSON data against a schema.
+
+## Features
+
+- Parses JSON strings with detailed error reporting
+- Validates JSON data against a schema with comprehensive validation rules
+- Supports nested objects and arrays
+- Provides detailed error messages for validation failures
+
+## Installation
+
+The function is part of the utils module in this project:
+
+```javascript
+const { parseAndValidateJSON } = require('./src/utils');
+```
+
+## Usage
+
+### Basic Parsing
+
+```javascript
+const { parseAndValidateJSON } = require('./src/utils');
+
+// Parse JSON without validation
+const jsonString = '{"name": "John", "age": 30}';
+const data = parseAndValidateJSON(jsonString);
+console.log(data); // { name: 'John', age: 30 }
+```
+
+### Parsing with Schema Validation
+
+```javascript
+const jsonString = '{"username": "john_doe", "email": "john@example.com", "age": 25}';
+
+const schema = {
+  required: ["username", "email"],
+  properties: {
+    username: { 
+      type: "string",
+      minLength: 3,
+      maxLength: 20
+    },
+    email: { 
+      type: "string" 
+    },
+    age: { 
+      type: "number", 
+      minimum: 0, 
+      maximum: 120 
+    }
+  }
+};
+
+try {
+  const data = parseAndValidateJSON(jsonString, schema);
+  console.log('Valid data:', data);
+} catch (error) {
+  console.error('Validation failed:', error.message);
+}
+```
+
+## Schema Validation Rules
+
+The schema validation supports the following rules:
+
+- `required`: Array of required field names
+- `properties`: Object defining property validation rules
+- `type`: Data type (string, number, boolean, object, array)
+- `enum`: Array of allowed values
+- `minimum`/`maximum`: Numeric range limits
+- `minLength`/`maxLength`: String length limits
+- `minItems`/`maxItems`: Array size limits
+- `nullable`: Allow null values when set to true
+- `items`: Schema for array items
+- Nested object validation through recursive schema definitions
+
+## Examples
+
+See `examples/json-parser-example.js` for comprehensive usage examples.
+
+## Testing
+
+Run the tests with:
+
+```bash
+node test/json-parser-test.js
+```
+
+## Error Handling
+
+The function throws descriptive errors for:
+
+- Invalid JSON syntax
+- Missing required fields
+- Type mismatches
+- Value out of range
+- String length violations
+- Array size violations
+- Enum value violations

package/docs/rest_client.md

@@ -0,0 +1,144 @@
+# REST Client Documentation
+
+The REST Client is a simple, promise-based HTTP client for making requests to REST APIs. It provides methods for all common HTTP verbs and handles JSON serialization/deserialization automatically.
+
+## Installation
+
+The REST Client is part of the Stigmergy CLI project and is available at `src/core/rest_client.js`.
+
+## Usage
+
+### Importing the Client
+
+```javascript
+const RestClient = require('./src/core/rest_client');
+```
+
+### Creating an Instance
+
+```javascript
+// Create a client with a base URL
+const client = new RestClient('https://api.example.com');
+
+// Create a client with default headers
+const client = new RestClient('https://api.example.com', {
+  'Authorization': 'Bearer your-token',
+  'Content-Type': 'application/json'
+});
+```
+
+### Making Requests
+
+#### GET Requests
+
+```javascript
+// Simple GET request
+const response = await client.get('/users');
+
+// GET request with query parameters
+const response = await client.get('/users', {
+  params: {
+    page: 1,
+    limit: 10
+  }
+});
+
+// GET request with custom headers
+const response = await client.get('/users', {
+  headers: {
+    'X-API-Key': 'your-key'
+  }
+});
+```
+
+#### POST Requests
+
+```javascript
+// POST request with JSON data
+const userData = {
+  name: 'John Doe',
+  email: 'john@example.com'
+};
+
+const response = await client.post('/users', userData);
+
+// POST request with custom headers
+const response = await client.post('/users', userData, {
+  headers: {
+    'X-API-Key': 'your-key'
+  }
+});
+```
+
+#### PUT and PATCH Requests
+
+```javascript
+// PUT request
+const response = await client.put('/users/123', updatedUserData);
+
+// PATCH request
+const response = await client.patch('/users/123', partialUpdateData);
+```
+
+#### DELETE Requests
+
+```javascript
+// DELETE request
+const response = await client.delete('/users/123');
+```
+
+### Setting Default Headers
+
+```javascript
+// Set default headers for all requests
+client.setDefaultHeaders({
+  'Authorization': 'Bearer your-token',
+  'X-API-Key': 'your-key'
+});
+
+// Set authorization header specifically
+client.setAuthorization('your-token'); // Defaults to Bearer
+client.setAuthorization('your-token', 'Basic'); // Specify token type
+```
+
+### Response Format
+
+All methods return a Promise that resolves to a response object with the following structure:
+
+```javascript
+{
+  status: 200,           // HTTP status code
+  statusText: 'OK',      // HTTP status text
+  headers: {},           // Response headers
+  data: {}               // Response data (parsed JSON or text)
+}
+```
+
+### Error Handling
+
+Errors are thrown as JavaScript Error objects with descriptive messages:
+
+```javascript
+try {
+  const response = await client.get('/users');
+  console.log(response.data);
+} catch (error) {
+  console.error('Request failed:', error.message);
+}
+```
+
+## Examples
+
+See `examples/rest_client_example.js` for complete usage examples.
+
+## Running Tests
+
+```bash
+npm run test:rest-client
+```
+
+## Running Examples
+
+```bash
+npm run example:rest-client
+```

package/examples/encryption-example.js

@@ -0,0 +1,67 @@
+/**
+ * Example usage of the encryption functions
+ */
+
+const { encryptData, decryptData, generateKey } = require('../src/utils');
+
+// Generate a secure key (in production, use a proper key management system)
+const secretKey = generateKey();
+
+console.log('Data Encryption Example');
+console.log('=====================');
+
+// Data to encrypt
+const plaintext = "This is confidential information that needs to be protected.";
+
+console.log('Original data:', plaintext);
+
+try {
+  // Encrypt the data
+  const encryptedObj = encryptData(plaintext, secretKey);
+  console.log('\nEncrypted data:');
+  console.log('Encrypted:', encryptedObj.encryptedData);
+  console.log('IV:', encryptedObj.iv);
+  console.log('Auth Tag:', encryptedObj.authTag);
+
+  // Decrypt the data
+  const decrypted = decryptData(encryptedObj, secretKey);
+  console.log('\nDecrypted data:', decrypted);
+  
+  // Verify data integrity
+  console.log('\nData integrity check:', plaintext === decrypted ? 'PASS' : 'FAIL');
+  
+} catch (error) {
+  console.error('Encryption/decryption failed:', error.message);
+}
+
+// Example with different data types
+console.log('\n\nExample with different data types:');
+console.log('---------------------------------');
+
+// Working with buffers
+const bufferData = Buffer.from('Binary data to encrypt', 'utf8');
+console.log('Buffer data to encrypt:', bufferData.toString('utf8'));
+
+try {
+  const encryptedBuffer = encryptData(bufferData, secretKey);
+  const decryptedBuffer = decryptData(encryptedBuffer, secretKey);
+  console.log('Decrypted buffer data:', decryptedBuffer);
+} catch (error) {
+  console.error('Buffer encryption failed:', error.message);
+}
+
+// Working with Unicode characters
+console.log('\nUnicode example:');
+const unicodeData = "Hello, 世界! 🌍 Welcome to 数据加密!";
+console.log('Unicode data to encrypt:', unicodeData);
+
+try {
+  const encryptedUnicode = encryptData(unicodeData, secretKey);
+  const decryptedUnicode = decryptData(encryptedUnicode, secretKey);
+  console.log('Decrypted unicode data:', decryptedUnicode);
+  console.log('Unicode integrity check:', unicodeData === decryptedUnicode ? 'PASS' : 'FAIL');
+} catch (error) {
+  console.error('Unicode encryption failed:', error.message);
+}
+
+console.log('\nExample completed.');