this.me 2.9.3 → 2.9.5

package/README.md

@@ -1,128 +1,258 @@
-<img src="https://suign.github.io/assets/imgs/Cleaker-removebg-preview.png" alt="Cleak Me Please." width="244">
+<img src="https://docs.neurons.me/media/all-this/webP/this.me.webp" alt="SVG Image" width="250" height="250">
 
 # THIS.ME  
-**This.Me** is a data-structured identity.
-<img src="https://suign.github.io/assets/imgs/point.png" alt="Me" width="144"> Consider **.me** as a point.
+> **This.Me** is a data-structured identity designed to generate and manage identities, attributes, properties and more. It combines privacy, user control, and secure interoperability.
 
-1. ### **Install `this.me`:**
+**.me** is a local, encrypted identity object designed to return ownership of identity back to the user. Its core philosophy is **user sovereignty**: your identity lives on your machine, under your control, not in someone else’s cloud. It holds attributes, relationships, and keys that define who you are—and crucially, **how you relate to others**.
+
+Each **.me** instance can pair with other authorities or identities using its **cryptographic keys**, establishing **trust through signatures and endorsements** rather than centralized verification. Instead of logging in through third-party services, you can validate your identity or vouch for someone else’s using these key exchanges. This enables a decentralized trust model where relationships are verifiable, persistent, and portable—empowering systems to recognize who you are based on real, user-generated signals, not institutional permissions.
+
+# Getting Started:
+1. ##### **Install `this.me`:**
    Open your terminal and run the following command to install the `this.me` package:
    ```js
-   npm install this.me
-   ```
-   
-2. ### **Import `Me` in Your Project:**
-   In the JavaScript file where you want to use `this.me`, import the `Me` class.
-   ```js
-   import Me from 'this.me';
+   npm i -g this.me
    ```
-   
-   **Explanation**
-   ​	•	The **be** method in the **Me** class accepts an object of **key-value pairs** and **adds these to the identity object**.
-   ​	•	You can call **me.be()** multiple times with different attributes to dynamically update the identity object.
-   
-   ```javascript
-   // Create a new Me instance
-   let me = new Me("xyxyxy");
-   
-   // Add attributes to the identity
-   me.be({ a: "XXX", b: "YYY" });
-   me.be({ c: "z" });
+
+2. **Run this command on your terminal:**
+
+   ```bash
+   me
    ```
 
-**A less abstract example:**
+The **Me** class represents a **persistent identity**, stored as an encrypted file (username.me) in ~/.this/me. This file contains:
 
-```js
-// Add attributes to the identity
-me.be({ name: "Alice", phone: "33550000" });
-```
+- An identifier (username)
+- Keys (private/public — currently placeholders)
+- User-defined attributes
+- Relationships and other social elements (reactions, attributies, properties, endorsements...)
 
-**1. Registry as a Service:**
+It can be **created**, **read** (if you have the correct hash), **modified in memory**, and then **saved again** in encrypted form.
 
-• The registry becomes a centralized service hosted by an authority (e.g., neurons.me).
+# Command Line Options:
 
-• This service would handle the verification and management of all Me instances across the network.
+### **me create**
 
-**Example Flow:**
+- **Description**: Creates a new .me identity.
+- **Flow**: Prompts for username and hash (secret key), then saves an encrypted file at ~/.this/me/username.me.
 
-1. **Setup**: A developer installs this.me and configures it to connect to neurons.me.
+------
 
-2. **User Registration**: Users register their Me identity through the service, and the library connects to the neurons.me registry for verification.
+### **me show [username]**
 
-3. **Service Interaction**: When a user interacts with a service that uses this.me, the service can trust the identity by querying the selected registry.
+- **Description**: Shows the decrypted contents of an identity.
+- **Flow**:
+  - If [username] is not provided, it prompts for it.
+  - Always prompts for the hash to unlock the identity.
+  - If successful, prints the identity as JSON.
 
-**Implementation:**
+------
 
-```js
-import Me from 'this.me';
-const config = {
-  registryURL: 'https://registry.neurons.me', // Registry authority URL
-};
-let me = new Me('alice', config);
-me.register({ password: 'securePass123', email: 'alice@example.com' });
-// Verify and interact with services using the connected registry
+### **me list**
+
+- **Description**: Lists all local .me identities.
+- **Flow**: Reads the ~/.this/me directory and prints all .me files (usernames).
+
+------
+
+# **Me Class Constructor**
+
+```
+constructor(username)
 ```
 
+Initializes:
 
+- this.username: the username
+- this.filePath: path to the encrypted file (/Users/youruser/.this/me/username.me)
+- this.unlocked: whether the identity is unlocked in memory (RAM)
+- this.data: decrypted content (attributes, keys, relationships)
 
---------
-<img src="https://suign.github.io/assets/imgs/monads.png" alt="Cleak Me Please" width="244">Hello, I am **.me**
+> It doesn’t load anything yet—just defines the path and initial state.
 
-### ❯ add.me 
-----
+------
 
-###### Using the CLI and this.me globally to manage user sessions.
+### **save(hash)**
 
-```bash
-npm i -g this.me
+```
+save(hash)
 ```
 
+- Encrypts this.data using AES-256-CBC.
+- Uses a random iv and a key derived from the hash (acting like a passphrase).
+- Saves the file as: iv + encryptedBuffer.
 
-### Neural Networks - **One-Hot Encoding**
---------
-To represent the combinations of **“me, you, him, her, it, us, them”** in a neural network, we need to convert the elements into a suitable format for neural network processing, such as one-hot encoding, and design a neural network architecture that can process these inputs.
+> ⚠️ Throws an error if this.data is not set.
 
-Here’s a step-by-step approach to achieve this:
-1.	**One-Hot Encoding:** Convert each element (“me”, “you”, “him”, “her”, “it”, “us”, “them”) into a one-hot encoded vector.
-2.	**Combination Representation:** Create input vectors for each combination by combining the one-hot encoded vectors.
-3.	**Neural Network Design:** Design a simple neural network to process these input vectors.
+------
 
-#### Step 1: One-Hot Encoding
-One-hot encoding represents each element as a binary vector with a single high (1) value and the rest low (0). For the elements “me”, “you”, “him”, “her”, “it”, “us”, “them”, we can assign the following one-hot encoded vectors:
+### **.unlock(hash)**
 
-```js
-// Create Me instances
-const meInstance = new Me('me');
-const youInstance = new Me('you');
-const himInstance = new Me('him');
-const herInstance = new Me('her');
-const itInstance = new Me('it');
-const usInstance = new Me('us');
-const themInstance = new Me('them');
-
-// One-hot encoding representation
-const subjects = {
-  'me': [1, 0, 0, 0, 0, 0, 0],
-  'you': [0, 1, 0, 0, 0, 0, 0],
-  'him': [0, 0, 1, 0, 0, 0, 0],
-  'her': [0, 0, 0, 1, 0, 0, 0],
-  'it': [0, 0, 0, 0, 1, 0, 0],
-  'us': [0, 0, 0, 0, 0, 1, 0],
-  'them': [0, 0, 0, 0, 0, 0, 1]
-};
+```javascript
+unlock(hash)
+```
+
+- Loads the .me file from disk.
+- Uses the first 16 bytes as the IV.
+- Attempts to decrypt the rest using the key derived from the hash.
+- If successful, stores the content in this.data and marks .unlocked = true.
+
+> 🔒 If it fails, returns false (likely due to a wrong hash or a corrupted file).
+
+------
+
+### **.lock()**
+
+```javascript
+lock()
+```
+
+Clears this.data from memory and sets .unlocked = false.
+
+------
+
+### **.create(username, hash) (static)**
+
+```javascript
+static create(username, hash)
 ```
 
-#### Step 2: Combination Representation
-For each combination, we can create an input vector by combining the one-hot encoded vectors of its elements. For example:
-Combination “me, you” would be represented as the sum of the one-hot vectors for “me” and “you”:
+- If the file already exists, throws an error.
+- Creates a new Me object with the structure:
 
+```javascript
+{
+  identity: { username, publicKey, privateKey },
+  attributes: {},
+  relationships: [],
+  reactions: [],
+  endorsements: []
+}
 ```
-[1, 0, 0, 0, 0, 0, 0] + [0, 1, 0, 0, 0, 0, 0] = [1, 1, 0, 0, 0, 0, 0]
+
+- Then calls .save(hash) to store the encrypted identity.
+
+------
+
+### **.load(username, hash) (static)**
+
+```javascript
+static load(username, hash)
 ```
+
+- Creates a new Me instance.
+- Calls .unlock(hash) to try decrypting it.
+- If successful, returns the instance.
+- If not, throws an error.
+
 ---
-### Me Deviation Formula
-**How Spread Out the data Points are around the .me?**
 
+### **Social Methods**
+
+#### **.addEndorsement(endorsement)**
+
+Agrega una firma externa (ej: Alice confía en Bob) a la identidad desbloqueada.
+
+#### **.be(key, value)**
+
+The **be** method in the **Me** class accepts an object of **key-value pairs** and **adds these to the identity object**.
+   ​•You can call **me.be()** multiple times with different attributes to dynamically update the identity object.
+
+   ```javascript
+// Create a new Me instance
+let me = new Me("xyxyxy");
+// Add attributes to the identity
+me.be({ a: "XXX", b: "YYY" });
+me.be({ c: "z" });
+   ```
+
+**A less abstract example:**
+
+```js
+// Add attributes to the identity
+me.be({ name: "Alice", phone: "33550000" });
+```
+
+------
+
+   ## 🔍 Core Principles
+
+1. **Freedom to Declare**
+   Anyone can generate a `.me` identity locally without external approval.
+2. **Trusted Endorsements**
+   Authorities (e.g., Cleaker) can endorse `.me` identities without controlling them.
+3. **Local Ownership**
+   All sensitive data (including private keys) stays on the user's machine.
+
+---
+## 📁 File Structure
+* `~/.this/me/username.me.json` — Encrypted identity file
+* `.me` includes:
+
+  * `username`
+  * `publicKey`, `privateKey` (encrypted)
+  * `attributes`, `relationships`, `reactions`, `properties`, `relationships`
+  * `endorsements`
+
+---
+## 🔐 Cryptographic Model
+* Identity is unlocked using a user-defined `hash` (password).
+* This hash decrypts the local `.me` file.
+* The identity includes:
+
+  * A **key pair** (public/private) for signing and verification.
+  * Optional **endorsements** signed by Cleaker or other authorities.
+
+---
+## 🛡️ Security Model
+* No private key ever leaves the local `.me` file.
+* Endorsements are public and verifiable using the public key.
+* If compromised, user can rotate keys and notify authorities.
+
+---
+## 🌐 Multi-Device Support
+* `.me` can be restored using a seed phrase or backup.
+* New devices can be authorized using signatures from old devices.
+
+---
+## ⚖️ Responsibilities
+* **this.me**
+  * Local file management, encryption, signing.
+  * CLI + API for usage.
+
+* **Cleaker / Authorities**
+
+  * Store trusted records of `username` + `publicKey`
+  * Provide validation/endorsement services.
+
+---
+## 🌍 Use Cases
+* Digital signature of documents
+* Smart contract interaction
+* Federated profiles with trust anchors
+* Group identity and shared contexts (`me && you && them in context/friends`)
+
+---
+By default, **this.me** uses the **local file system (~/.this/me/)** to store and manage identity data.
+No external service is required.
+
+   ​<img src="https://suign.github.io/assets/imgs/monads.png" alt="Cleak Me Please" width="244">Hello, I am **.me**
+
+### ❯ add.me 
+----
+
+# What is All.This?
+###### Modular Data Structures:
+**Each module** in **[all.this](https://neurons.me/all-this)** represents a specific **datastructure**. These **classes** encapsulate the functionalities and **data specific to their domain.**
+
+**[this.me](https://docs.neurons.me/this.me/index.html)  - [this.audio](https://docs.neurons.me/this.audio/index.html) - [this.text](https://docs.neurons.me/this.text/index.html) - [this.wallet](https://docs.neurons.me/this.wallet/index.html) - [this.img](https://docs.neurons.me/this.img/index.html) - [this.pixel](https://docs.neurons.me/this.pixel/index.html) - [be.this](https://docs.neurons.me/be.this/index.html) - [this.DOM](https://docs.neurons.me/this.DOM/index.html) - [this.env](https://docs.neurons.me/this.env/index.html) - [this.GUI](https://docs.neurons.me/this.GUI/index.html) - [this.be](https://docs.neurons.me/this.be/index.html) - [this.video](https://docs.neurons.me/this.video/index.html) - [this.dictionaries](https://docs.neurons.me/this.dictionaries/index.html)** 
 
-----------
+#### Contribution
+If you are interested in collaborating or wish to share your insights, please feel free to reach out or contribute to the project.
 
+#### License & Policies
+- **License**: MIT License.
+- **Learn more** at **https://neurons.me**
+  [Terms](https://docs.neurons.me/terms-and-conditions) | [Privacy](https://docs.neurons.me/privacy-policy)
 
+  <img src="https://docs.neurons.me/neurons.me.webp" alt="neurons.me logo" width="123" height="123">

package/bin/me.cli.js

@@ -0,0 +1,99 @@
+#!/usr/bin/env node
+// ./bin/me.cli.js
+import { Command } from 'commander';
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import { existsSync } from 'fs';
+import path from 'path';
+import os from 'os';
+import Me from '../src/me.js';
+import { validateSetup } from '../src/scripts/setup_validation.js';
+validateSetup(); // Asegura que ~/.this y ~/.this/me existen antes de usar el CLI
+const program = new Command();
+const ME_DIR = path.join(os.homedir(), '.this', 'me');
+// Utilidad para obtener ruta de archivo `.me`
+const getMeFilePath = (username) => path.join(ME_DIR, `${username}.me`);
+program
+  .name('me')
+  .description('CLI to manage this.me identities')
+  .version('1.0.0');
+// Comando: crear una identidad .me
+program
+  .command('create')
+  .description('Create new .me identity')
+  .action(async () => {
+    const { username, hash } = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'username',
+        message: 'Enter a username:',
+      },
+      {
+        type: 'password',
+        name: 'hash',
+        message: 'Define your hash (secret key):',
+        mask: '*',
+      }
+    ]);
+    const mePath = getMeFilePath(username);
+    if (existsSync(mePath)) {
+      console.log(chalk.red(`❌ Identity '${username}' already exists.`));
+      return;
+    }
+    const me = await Me.create(username, hash);
+    console.log(chalk.green(`✅ Identity '${me.username}' created and saved as ${mePath}`));
+  });
+
+// Command: show identity contents
+program
+  .command('show')
+  .description('Show contents of a .me identity')
+  .argument('[username]', 'Username of the identity to show')
+  .action(async (usernameArg) => {
+    const { username, hash } = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'username',
+        message: 'Enter username to view:',
+        when: () => !usernameArg,
+      },
+      {
+        type: 'password',
+        name: 'hash',
+        message: 'Enter your hash to unlock:',
+        mask: '*',
+      }
+    ]);
+
+    const finalUsername = usernameArg || username;
+
+    try {
+      const me = await Me.load(finalUsername, hash);
+      console.log(chalk.cyan(`\n📂 Identity '${finalUsername}':\n`));
+      console.log(JSON.stringify(me, null, 2));
+    } catch (err) {
+      console.log(chalk.red(`Error: ${err.message}`));
+    }
+  });
+
+// Comando: listar identidades locales
+program
+  .command('list')
+  .description('List available local .me identities')
+  .action(async () => {
+    const fs = await import('fs/promises');
+    fs.readdir(ME_DIR)
+      .then(files => {
+        const meFiles = files.filter(file => file.endsWith('.me'));
+        if (meFiles.length === 0) {
+          console.log(chalk.yellow('⚠️  No registered identities found.'));
+        } else {
+          console.log(chalk.cyan('📇 Available identities:'));
+          meFiles.forEach(file => console.log('•', file.replace('.me', '')));
+          console.log(chalk.gray('\nTip: Use `me show` or `me show <username>` to view identity contents.'));
+        }
+      })
+      .catch(err => console.log(chalk.red(`Error: ${err.message}`)));
+  });
+
+program.parse(process.argv);

package/index.js

@@ -1,10 +1,12 @@
-//index.js
+// index.js
 /**
  * @module This.Me
  * @description
  *  This.Me is a data-structured identity...    
- * */
+ */
 
+import { validateSetup } from './src/scripts/setup_validation.js';
+validateSetup(); // Asegura que ~/.this y ~/.this/me existen antes de continuar
 import Me from './src/me.js';
-//when a user declares "I am %.me," their digital existence is affirmed and recorded in the system.
-export default Me;
+// when a user declares "I am %.me," their digital existence is affirmed and recorded in the system.
+export default Me;

package/jsdoc.json

@@ -1,10 +1,10 @@
 {
   "source": {
-    "include": ["./src/me.js", "./src/.me.cli.js", "./index.js", "./README.md"]
+    "include": ["./src", "./index.js", "./README.md"]
   },
   "opts": {
-    "destination": "./docs",
-    "template": "../../../suign.github.io/dev_tools/Sandbox/better-docs/",
+    "destination": "/mnt/neuroverse/https-neurons/subDomains/docs/public/this.me",
+    "template": "../../../suign.github.io/Sandbox/better-docs/",
     "readme": "./README.md"
   },
   "templates": {
@@ -17,32 +17,24 @@
       }
     },
     "better-docs": {
-      "name": "This.Me",
-      "title": "This.Me",
+      "name": "this.me",
+      "title": "this.me Docs",
       "css": "style.css",
       "trackingCode": "...",
       "hideGenerator": false,
       "navLinks": [
         {
           "label": "All.This",
-          "href": "https://suign.github.io/all.this/"
-      },
-      {
-        "label": "@Source",
-        "href": "https://suign.github.io/"
-    },
-          {
-              "label": "Github",
-              "href": "https://github.com/suiGn/this.me"
-          },
-          {
-              "label": "Cleaker.me",
-              "href": "https://cleaker.me"
-          },
-          {
-            "label": "What is all.this?",
-              "href": "https://www.neurons.me/this"
-          }
+          "href": "https://docs.neurons.me/all.this/"
+        },
+        {
+          "label": "Neurons.me",
+          "href": "https://neurons.me"
+        },
+        {
+          "label": "Github",
+          "href": "https://github.com/neurons-me/this.me"
+        }
       ]
         }
   }

package/notes/Entonces_Que_es_me.md

@@ -0,0 +1,9 @@
+👤 Entonces, ¿qué es .me?
+
+.me es el sujeto.
+Es quien dice “yo”.
+Es la llave privada, la biografía, la voluntad.
+
+.me es local, silencioso, estático.
+No “vive”, no escucha.
+Solo es consultado y afirma.