this.me 2.5.7 → 2.5.9

package/README.md

@@ -7,6 +7,12 @@ For every recursive action, there's a repercussion.
 npm install this.me
 ```
 
+Add to your project:
+
+```js
+let me = require('this.me');
+```
+
 **Docs:** [this.me](https://www.neurons.me/this-me)
 
 ### Conceptual Flow:
@@ -24,19 +30,78 @@ npm install this.me
 - [ ] Keep [i.mlearning](https://www.npmjs.com/package/i.mlearning).
 
   
+  
+  This model turns the traditional web model on its head. Users no longer depend on centralized authorities for identity or data management. They hold the keys (literally) to their identity and data. Services become more user-centric, providing services based on cryptographic proofs rather than centralized databases.
+  
+  While this approach offers many benefits, including enhanced privacy and user sovereignty, it's still nascent and requires a paradigm shift in development, deployment, and user education.
 
 # Setting up your Context. 	👋🏻👋🏼👋🏽👋🏾👋🏿
 Defining the environment and context in which your code runs, especially when you're interacting with intelligent agents or services like me.
-Having a clear declaration of the environment and the context can have a series of implications for security, interoperability, and clarity. 
-
-The codebase is often vast, dynamic, and continually evolving. 
-
-Given the dynamic nature of such environments, ensuring the integrity of the code and data becomes paramount. You wouldn't want an agent to execute or rely on code that has been tampered with or is different from the expected version. This is where hashing comes into play.
+Having a clear declaration of the environment and the context can have a series of implications for security, interoperability, and clarity. The codebase is often vast, dynamic, and continually evolving. Given the dynamic nature of such environments, ensuring the integrity of the code and data becomes paramount. You wouldn't want an agent to execute or rely on code that has been tampered with or is different from the expected version. This is where hashing comes into play.
 
 The **SHA256 cryptographic hash function** is used to produce a unique, fixed-length sequence of characters (a hash) for the data. This setup does a thorough job of hashing the content of files or entire directories.
 Even a tiny change in the content will result in a completely different hash.
  [Read More.](https://www.neurons.me/this-me#h.sg59uu9ka8i8)
 
+## Quickstart Guide: Understanding `Me`
+
+### Introduction:
+
+Run node demo.js for quick example.const Me = require('./me.js');
+
+```js
+// Create a new Me instance
+const suign = new Me('Suign Name', 'suign@email.com', '01/01/1990', { city: 'SampleCity', country: 'SampleCountry' }, { theme: 'dark', notifications: true });
+// Print out the public key (for demonstration purposes)
+console.log("Suign's Public Key:", suign.getPublicKey());
+// Example: Sign some data
+const dataToSign = "Hello, World!";
+const signature = suign.signData(dataToSign);
+console.log("Signature for 'Hello, World!':", signature.toString('base64')); // Base64 encoding just to make the signature more readable in console.
+// Example: Verify the signature
+const isValidSignature = suign.verifySignature(dataToSign, signature);
+console.log("Is the signature valid?", isValidSignature);
+```
+
+**`Me`** is a digital identity representation within a network. Rather than relying on traditional methods like username-password combinations, `Me` encapsulates the essence of an entity with cryptographic guarantees.
+
+### Key Features:
+
+1. **Cryptographic Identity**:
+   - Every instance of `Me` has a private and public key pair.
+   - These keys provide cryptographic proof of identity, allowing entities to sign and verify messages securely.
+2. **Profile Management**:
+   - `Me` contains information attributes such as name, email, birthdate, location, and preferences.
+   - These attributes can be updated and managed within the entity's lifecycle.
+3. **Network Interactions**:
+   - Being cryptographically unique, `Me` can safely interact with services on a network.
+   - It can register, authenticate, and perform actions with a guarantee of its identity.
+
+### Purpose:
+
+1. **Enhanced Security**
+   - Traditional authentication systems have vulnerabilities (e.g., password breaches). `Me` ensures that without the private key, impersonation is nearly impossible.
+2. **Decentralization Ready**
+   - `Me` fits perfectly in a decentralized environment, where trust is established not by central entities, but by cryptographic proofs.
+3. **User Centricity**
+   - The user has full control over their `Me` entity. They manage their keys and therefore their identity, making it resistant to censorship and external control.
+4. **Simplicity**
+   - Instead of managing multiple credentials for different services, `Me` offers a unified identity that's recognized across the network.
+
+### Getting Started:
+
+1. **Initialization**:
+   - Create an instance: `const myProfile = new Me('Name', 'email@email.com', 'birthdate', {location}, {preferences});`
+2. **Key Management**:
+   - Use integrated cryptographic methods to sign and verify data.
+   - Always ensure the private key remains confidential.
+3. **Interactions**:
+   - With the public key as an identifier, use `Me` to interact with services, sign transactions, or prove identity in network communications.
+
+------
+
+Remember, while `Me` provides enhanced security, the principle of key management is paramount. Losing access to the private key might mean losing access to the associated identity.
+
 Let's delve into the importance of such declarations:
 
 ### Security Context:

package/demo.js

@@ -0,0 +1,17 @@
+const Me = require('./me.js');
+
+// Create a new Me instance
+const suign = new Me('Suign Name', 'suign@email.com', '01/01/1990', { city: 'SampleCity', country: 'SampleCountry' }, { theme: 'dark', notifications: true });
+
+// Print out the public key (for demonstration purposes)
+console.log("Suign's Public Key:", suign.getPublicKey());
+
+// Example: Sign some data
+const dataToSign = "Hello, World!";
+const signature = suign.signData(dataToSign);
+
+console.log("Signature for 'Hello, World!':", signature.toString('base64')); // Base64 encoding just to make the signature more readable in console.
+
+// Example: Verify the signature
+const isValidSignature = suign.verifySignature(dataToSign, signature);
+console.log("Is the signature valid?", isValidSignature);

package/main.js

@@ -9,6 +9,17 @@ const neurons = require("neurons.me");
 const cleaker = require("cleaker");
 const netget = require("netget");
 const Atom = require("this.atom");
+//User Context.
+const Me = require("./me");
+const os = require('os');
+const me = new Me(
+  'Me', 
+  'replace@email.me', 
+  'replaceDateOfBirth',
+   { city: 'replaceCity',
+    country: 'replaceCountry' }, 
+    { theme: 'dark' }
+    );
 // Your CLI logic goes here, display welcome message, handle other commands, etc.
 function displayWelcomeMessage() {
   console.log(`
@@ -26,17 +37,13 @@ function displayWelcomeMessage() {
 [---------------------------------.me-----------]
 -^^^^^^^^zzzz...
 Welcome to .me - Your AI Playground
-give me one sec please...
 `);
+console.log(me.getPublicKey());
+const cleaked = new cleaker();
+console.log(`Host_Session@ ${os.userInfo().username}`);
+console.log("System Role: ", cleaked.role);
 };
 
-//User Context.
-const Me = require("./me");
-const me = new Me();
-const os = require('os');
-console.log(`Host_Session@ ${os.userInfo().username}`);
-const cleaked = new cleaker();
-console.log(cleaked.role);
 //ATOMS ELECTRONS AND PARTICLES IN PROGRESS...
 //WE WILL RUN OUR NODE PROCCESSES IN ELECTRON WINDOWS AND EACH ATOM WILL HOLD ELECTRONS WHICH HOLDS THE PROCESSES
 //THUS WE WILL KNOW HOW CHARGED AN ATOM IS BY THE NUMBER OF ELECTRONS IT HAS AND HOW MANY PROCESSES IT IS RUNNING.
@@ -86,14 +93,11 @@ function handleAtomCommand() {
   }
 }
 
-// Display the welcome message
-displayWelcomeMessage();
-
 // COMMAND HANDLERS
 switch(args[0]) {
   case 'hash-src':
-        hashSrc();
-        break;
+      hashSrc();
+      break;
   case 'viewer':
       handleViewerCommand();
       break;
@@ -101,7 +105,10 @@ switch(args[0]) {
       handleAtomCommand();
       break;
   default:
-      console.log('Command not recognized. Use "viewer" or "atom" as arguments.');
+      // Here you can define what you'd like to happen when no arguments are passed.
+      displayWelcomeMessage();
+      // And any other functionality you'd like to execute
+      break;
 }
 
 module.exports = {

package/me.js

@@ -1,18 +1,43 @@
 // me.js
+const crypto = require('crypto');
 class Me {
     constructor(name, email, birthDate, location = {}, preferences = {}) {
-        this.name = name; // Full name
-        this.email = email; // Email address
-        this.birthDate = birthDate; // Birthdate
-        this.location = location; // Location object { city: '...', country: '...', ...}
-        this.preferences = preferences; // User's preferences or settings, it could be an object { theme: 'dark', notifications: true, ...}
-        // Add other attributes pertinent to the profile as needed.
+        this.name = name;
+        this.email = email;
+        this.birthDate = birthDate;
+        this.location = location;
+        this.preferences = preferences;
+        // Generate key pair upon instantiation
+        this.keyPair = this.generateKeyPair();
+    }
+    generateKeyPair() {
+        const { privateKey, publicKey } = crypto.generateKeyPairSync('rsa', {
+            modulusLength: 2048,
+        });
+        return {
+            privateKey: privateKey.export({ type: 'pkcs1', format: 'pem' }),
+            publicKey: publicKey.export({ type: 'pkcs1', format: 'pem' }),
+        };
+    }
+    getPublicKey() {
+        return this.keyPair.publicKey;
+    }
+    // Use the private key for signing data, and the public key can be shared for verification
+    signData(data) {
+        const sign = crypto.createSign('SHA256');
+        sign.update(data);
+        sign.end();
+        return sign.sign(this.keyPair.privateKey);
+    }
+    verifySignature(data, signature) {
+        const verify = crypto.createVerify('SHA256');
+        verify.update(data);
+        verify.end();
+        return verify.verify(this.keyPair.publicKey, signature);
     }
-    // Method to update location
     updateLocation(newLocation) {
         this.location = newLocation;
     }
-    // Add other methods to get, set, or update profile details as needed.
+    // Add other methods as required.
 }
-
 module.exports = Me;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "this.me",
-  "version": "2.5.7",
+  "version": "2.5.9",
   "description": "This.me should This.be",
   "bin": {
     ".me": "./main.js"