this.me 2.7.5 → 2.7.7

package/Me.js

@@ -0,0 +1,71 @@
+//Me.js
+let cryptoModule;
+if (typeof window !== 'undefined' && typeof window.crypto !== 'undefined') {
+    cryptoModule = require('./crypto/crypto-browser');
+} else {
+    cryptoModule = require('./crypto/crypto-node');
+}
+
+class Me {
+    constructor(name, email, birthDate, location = {}, preferences = {}) {
+        this.name = name;
+        this.email = email;
+        this.birthDate = birthDate;
+        this.location = location;
+        this.preferences = preferences;
+        // Social Media Accounts
+        this.socialMedia = {
+            facebook: {
+                appId: 'YOUR_FACEBOOK_APP_ID', // Replace with your actual Facebook App ID
+                token: null
+            }
+            // ... You can add more platforms here
+        };
+        // Generate key pair upon instantiation
+        this.keyPair = cryptoModule.generateKeyPair();
+    }
+    
+    connectFacebook(token) {
+        this.socialMedia.facebook.token = token;
+        // You can expand this function to do more, like fetch the user's profile data using the token.
+    }
+
+    getFacebookToken() {
+        return this.socialMedia.facebook.token;
+    }
+
+    // the public key can be shared for verification
+    getPublicKey() {
+        return this.keyPair.publicKey;
+    }
+    // Use the private key for signing data.
+    signData(data) {
+        try {
+            const sign = cryptoModule.createSign('SHA256');
+            sign.update(data);
+            sign.end();
+            return sign.sign(this.keyPair.privateKey);
+        } catch (err) {
+            console.error("Error during signing data: ", err);
+            return null;
+        }
+    }
+
+    verifySignature(data, signature) {
+        try {
+            const verify = cryptoModule.createVerify('SHA256');
+            verify.update(data);
+            verify.end();
+            return verify.verify(this.keyPair.publicKey, signature);
+        } catch (err) {
+            console.error("Error during verifying signature: ", err);
+            return false;
+        }
+    }
+
+    updateLocation(newLocation) {
+        this.location = newLocation;
+    }
+}
+
+module.exports = Me;

package/README.md

@@ -1,91 +1,26 @@
 <img src="./_._.svg" alt="SVG Image" width="123" height="123" style="width123px; height:123px;">
 
-# .me Suite - Your AI Playground
-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:
-- [ ] Set up your context with [this.me.](https://www.npmjs.com/package/this.me)
-- [ ] Create a neural network using [neurons.me](https://www.neurons.me).
-- [ ] Define the data you'd like your neural network to recognize or process with [this.](https://www.neurons.me/this) modules.
-- [ ] Use [this.be](https://www.npmjs.com/package/this.be) to maintain a state or context, - watching over  [This](https://www.neurons.me/this) and any other states you define for example.
-- [ ] Define desired status and handlers, [be.this](https://www.npmjs.com/package/be.this).
-- [ ] Keep [i.mlearning](https://www.npmjs.com/package/i.mlearning).
-
-# Quick Start with Sandbox.
-
-1. **Clone this Sandbox Demo Repository**
-
-  ```bash
-  git clone https://github.com/suiGn/sandbox.git
-  ```
-2. **Navigate to the Project Directory**
-
-  ```bash
-  cd .me
-  ```
-3. **Install Dependencies**
-You can use either Yarn or npm to install the necessary dependencies.
-
-**Using Yarn:**
-
-```bash
-yarn install
-```
-
-**Using npm:**
-
-```bash
-npm install
-```
-
-4. **Launch the Application**
-
-  ```bash
-  npx electron index.js
-  ```
-
-  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.
-
-In an audacious twist of fate, I decided to circumvent the monotony of user session code and dive into the cryptographic labyrinth. Rather than getting bogged down by yawn-worthy password management and playing custodian to a sea of data, I embraced a vision where every individual holds the scepter to their digital kingdom. Centralized authorities? Toss 'em out the window. Here, you own your identity, seal it with cryptographic flair, and let no one else govern it. Sure, crafting a cryptographic symphony is no walk in the park, but compared to the drudgery of traditional server management, it feels like reinventing the wheel... but in a world where wheels were never round to begin with. Behold a system where every user is a master, every piece of data a treasure, all guarded by codes and ciphers. A little unorthodox, perhaps, but in an age of digital renaissance, who wants orthodox anyway?
-
- I'd sooner recode the Old and New Testaments, heck, throw in the Qabala too, in ASCII, before willingly plunging into the dull abyss of server-side user session management. Why swim in those murky waters when I can bask in the cryptographic labyrinth? Ditching the monotony of password management, I decided to champion a world where every individual becomes the keeper of their digital realms. Centralized authorities? More like relics of a bygone era. Here, you don't just own your identity; you seal it with cryptographic brilliance, untouched and ungoverned by any other. Crafting this cryptographic symphony may seem daunting, but compared to the tedium of server management? 
-
-POC || GTFO but for now I am traveling to new york.
+# .me  
+I decided to circumvent the monotony of user session code and dive into the cryptographic labyrinth.
+ I'd sooner recode the Old and New Testaments, heck, throw in the Qabala too, in ASCII, before willingly plunging into the dull abyss of server-side user session management.
 
 # 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.
-
-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)
+Continue reading about this:
+https://www.mlearning.studio/data-formats/this-me
 
 ## Quickstart Guide: Understanding `Me`
-
-### Introduction:
-
 Run node **demo.js** for quick example.
 
 ```js
-const Me = require('./me.js');
+const Me = require('this.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)
+// Print out the public key
 console.log("Suign's Public Key:", suign.getPublicKey());
 // Example: Sign some data
 const dataToSign = "Hello, World!";
@@ -96,7 +31,7 @@ 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.
+**`Me`** is a digital identity representation. `Me` encapsulates the essence of an entity with cryptographic guarantees.
 
 ### Key Features:
 
@@ -111,7 +46,6 @@ console.log("Is the signature valid?", isValidSignature);
    - 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**
@@ -121,109 +55,13 @@ console.log("Is the signature valid?", isValidSignature);
 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:
-Defining the environment ensures that both the user and the IA have a clear understanding of the boundary within which interactions take place.
-Explicitly stating the environment can prevent unintended cross-boundary actions. For instance, without a clear declaration, an IA might access files or services that are beyond its permitted scope, leading to potential security vulnerabilities.
-A well-defined environment acts as a sandbox that can restrict unauthorized or unintended activities. For instance, browsers use a similar principle to run JavaScript in a sandboxed environment for security reasons.
-
-**Interoperability:**
-As the ecosystem of software and services becomes increasingly diverse, ensuring your code can interact smoothly with other systems becomes crucial.
-Declaring the environment or context helps ensure that all systems are on the "same page". For example, if an IA knows it's operating within the ".me" context, it can adjust its behavior, assumptions, and dependencies accordingly.
-
-**Auditability and Compliance:**
-For industries or applications where audit trails and compliance are important, having a clear declaration of the environment ensures that every interaction and operation can be traced back to a defined context.
-Such clear demarcations can aid in forensic analysis if something goes wrong or if there's a need to understand the context of an interaction.
-
 ### Conclusion:
 In the broader context of a dynamic and interactive environment like the one you're building, hashing becomes a powerful tool. It's not just about verifying code; it's about ensuring the entire ecosystem's security, integrity, and seamless operation. By employing a hashing mechanism, you're taking a proactive step towards establishing trust in the code and data that powers your system.
 
-### Dependencies:   
-```json
-"dependencies": {
-    "be.this": "^1.1.3",
-    "cleaker": "^2.2.9",
-    "i.mlearning": "^2.1.7",
-    "netget": "^2.1.6",
-    "neurons.me": "^2.6.3",
-    "this.atom": "^1.0.3",
-    "this.audio": "^1.0.0",
-    "this.be": "^2.1.3",
-    "this.dom": "^1.0.0",
-    "this.pixel": "^3.3.5",
-    "this.pixelgrid": "^3.3.2",
-    "this.text": "^1.0.0",
-    "v.path": "^2.1.7"
-  },
-```
-
 # Context of Abstraction for Machine Learning Standardization
-
-Traditional web development elements, from images to audio, are designed mainly for display and interaction. But what if they could be seamlessly converted into standardized formats primed for machine learning? That's the vision behind the **this.** modules.
-
-An Introduction to the this. JavaScript Library: Standardizing Web Development Elements for Machine Learning.
-
-## Principles Behind the this. Library:
-
-- ### **Abstraction for ML:**
-
- The library's core principle is to abstract traditional web elements so that they're immediately primed for machine learning. It's about viewing web content not just as data but as structured, consistent, and standardized data.
-
-- ### **Built on Web Standards:** 
-
-Rooted in JavaScript, the this. library builds upon public web development standards. The aim is to ensure that developers remain within familiar territories, even as they venture into the world of machine learning.
-
-- ### **Open and Collaborative:** 
-
-The this. library champions open standards. By leveraging public web standards, it invites collaboration, hoping to create a community that continually refines and enhances the bridge between web development and machine learning.
-
 [neurons.me](https://www.neurons.me)
-
 [neurons.me/this](https://www.neurons.me/this)
 
-# Clone THIS DEMO Playground
-Welcome to the THIS.ME Playground, where the entire THIS.ME suite comes together with NEURONS.ME to provide a rich development and execution environment for your AI adventures.
-
-## Sandbox Demo Quick Start
-### 1. Clone the Repository
-
-```bash
-git clone https://github.com/suiGn/.me.git
-```
-### 2. Navigate to the Project Directory
-```bash
-cd .me
-```
-### 3. Install Dependencies
-You can use either Yarn or npm to install the necessary dependencies.
-Using Yarn:
-```bash
-yarn install 
-```
-Using npm:
-```bash
-npm install
-```
-### 4. Launch the Application
-```
-npx electron index.js
-```
-
 **## License & Policies**
 \- ***\*License\****: MIT License (see LICENSE for details).
 \- ***\*Privacy Policy\****: Respects user privacy; no collection/storage of personal data.

package/demo.js

@@ -1,4 +1,4 @@
-const Me = require('./me.js');
+const Me = require('./me2.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)

package/main.js

@@ -5,15 +5,12 @@ const path = require("path");
 const crypto = require('crypto');
 const fs = require('fs');
 const args = process.argv.slice(2);
-const neurons = require("neurons.me");
-const cleaker = require("cleaker");
-const netget = require("netget");
 //User Context.
-const Me = require("./me");
 const os = require('os');
+const Me = require('./Me');
 const me = new Me(
   'Me', 
-  'replace@email.me', 
+  'enter your email.', 
   'replaceDateOfBirth',
    { city: 'replaceCity',
     country: 'replaceCountry' }, 
@@ -35,15 +32,11 @@ function displayWelcomeMessage() {
 |     ^^^^^^^^^^^^^^^^^^^^                      | 
 [---------------------------------.me-----------]
 -^^^^^^^^zzzz...
-Welcome to .me - Your AI Playground
+Welcome to .me.
 `);
-console.log(me.getPublicKey());
-const cleaked = new cleaker();
 console.log(`Host_Session@ ${os.userInfo().username}`);
-console.log("System Role: ", cleaked.role);
+console.log(`v.path@ ${os.homedir()}`);
 };
-
-
 //.. THIS SECTION IS FOR HASHING PURPOSES ...//
 /* Create a function that computes the hash of the @src directory.
  'hashSrc') to handle hashing when the relevant command is passed to the script.*/
@@ -52,7 +45,7 @@ console.log("System Role: ", cleaked.role);
  function hashSrc() {
   try {
       // Adjust this to the exact location of your @src directory
-      const srcDirPath = path.resolve(__dirname, '@src');
+      const srcDirPath = path.resolve(__dirname, '@me');
       const hash = hashThis(srcDirPath);
       console.log(`Hash of @src directory: ${hash}`);
   } catch (error) {
@@ -78,9 +71,6 @@ switch(args[0]) {
 }
 
 module.exports = {
-  cleaker,
-  netget,
-  neurons,
   getAllFiles,
   hashThis,
   hashSrc

package/me.html

@@ -0,0 +1,30 @@
+<html>
+    <head>
+        <title>.me</title>
+    </head>
+    <body>
+        Hello, me!
+        <script>
+            window.fbAsyncInit = function() {
+              FB.init({
+                appId      : '{your-app-id}',
+                cookie     : true,
+                xfbml      : true,
+                version    : '{api-version}'
+              });
+                
+              FB.AppEvents.logPageView();   
+                
+            };
+          
+            (function(d, s, id){
+               var js, fjs = d.getElementsByTagName(s)[0];
+               if (d.getElementById(id)) {return;}
+               js = d.createElement(s); js.id = id;
+               js.src = "https://connect.facebook.net/en_US/sdk.js";
+               fjs.parentNode.insertBefore(js, fjs);
+             }(document, 'script', 'facebook-jssdk'));
+          </script>
+    </body>
+    
+</html>

package/package.json

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

package/me.js

@@ -1,51 +0,0 @@
-// me.js
-let cryptoModule;
-if (typeof window !== 'undefined' && typeof window.crypto !== 'undefined') {
-    cryptoModule = require('./crypto/crypto-browser');
-} else {
-    cryptoModule = require('./crypto/crypto-node');
-}
-class Me {
-    constructor(name, email, birthDate, location = {}, preferences = {}) {
-        this.name = name;
-        this.email = email;
-        this.birthDate = birthDate;
-        this.location = location;
-        this.preferences = preferences;
-        // Generate key pair upon instantiation
-        this.keyPair = cryptoModule.generateKeyPair();
-        // ... rest of your class logic using the cryptoModule abstraction ...
-    }
-    // ... methods ...
-    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);
-    }
-    updateLocation(newLocation) {
-        this.location = newLocation;
-    }
-}
-module.exports = Me;
-
-