this.me 2.9.4 → 2.9.5

package/README.md

@@ -1,132 +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.
 
-this.me is designed to generate and manage identities. It's responsible for creating a user’s identity, handling attributes, and generating hashes.
+**.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**.
 
-Use Case: Suppose you're building an app where users need to create profiles or identities. You can install this.me locally in that project to manage user identities.
+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.
 
-1. ### **Install `this.me`:**
+# 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
+   npm i -g 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';
-   ```
-   
-   **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:**
+------
+
+### **me list**
+
+- **Description**: Lists all local .me identities.
+- **Flow**: Reads the ~/.this/me directory and prints all .me files (usernames).
+
+------
+
+# **Me Class Constructor**
 
-```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
+```
+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)
 ```
 
-#### 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”:
+- 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)
+```
+
+- 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.
+
+---
+
+### **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.
+
 ---
-### Me Deviation Formula
-**How Spread Out the data Points are around the .me?**
+## 📁 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,12 +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;
-
-console.log("this.me is loaded!!");
+// when a user declares "I am %.me," their digital existence is affirmed and recorded in the system.
+export default Me;

package/jsdoc.json

@@ -0,0 +1,41 @@
+{
+  "source": {
+    "include": ["./src", "./index.js", "./README.md"]
+  },
+  "opts": {
+    "destination": "/mnt/neuroverse/https-neurons/subDomains/docs/public/this.me",
+    "template": "../../../suign.github.io/Sandbox/better-docs/",
+    "readme": "./README.md"
+  },
+  "templates": {
+    "cleverLinks": false,
+    "monospaceLinks": false,
+    "search": true,
+    "default": {
+      "staticFiles": {
+        "include": ["./README.md"]
+      }
+    },
+    "better-docs": {
+      "name": "this.me",
+      "title": "this.me Docs",
+      "css": "style.css",
+      "trackingCode": "...",
+      "hideGenerator": false,
+      "navLinks": [
+        {
+          "label": "All.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.

package/notes/Index of this.me Structure.md

@@ -0,0 +1,154 @@
+### **Index of `this.me` Structure**
+Here’s a comprehensive list of the components and their purposes within the `this.me` class:
+
+#### **1. Identity**
+- **Description:** Immutable attributes defining the core identity of the user.
+  - Incluye claves criptográficas necesarias para autenticación, firma y encriptación.
+#### **2. Attributes**
+- **Description:** Flexible traits and descriptive properties of the user.
+#### **3. Relationships**
+- **Description:** Connections and associations with others.
+#### **4. Reactions**
+- **Description:** User’s interactions and engagements with the world.
+#### **5. Properties**
+- **Description:** Items owned or managed by the user.
+
+------
+
+### **1. The Me Structure Overview**
+
+#### **Core Components**
+- **Identity:** The foundation of the `this.me` object.
+
+  - Immutable attributes: `username`, `DID`, `publicKey`, `privateKey`.
+  - Core methods for validation, key generation, and secure signing.
+
+  - Example key storage:
+    ```json
+    {
+      "username": "jabellae",
+      "DID": "did:cleaker:xyz123",
+      "publicKey": "abc123...",
+      "privateKey": "<encrypted or local-only>"
+    }
+    ```
+
+  - Example method:
+    ```js
+    jabellae.sign("message to sign"); // Returns signature using stored private key
+    ```
+
+  ---
+
+- **Attributes:** Fundamental identity traits.
+  Store and manage user traits dynamically:
+  - Examples: Name, age, location, pronouns, bio.
+    **Use `.be()` to add or update attributes.**
+    Example: 
+    ```json
+    { name: 'John Doe', age: 30, location: 'Earth' }
+    ```
+    Implement `be()` as a flexible key-value store.
+    Add validation for specific attributes (if required).
+
+  --------
+
+- **Relationships:** Connections with others.
+  - Examples: Friends, groups, networks, organizations.
+    **Contacts:** Individual connections.
+    **Groups:** Collections of users with shared context.
+
+    ```js
+    .relationships.addContact({ username: 'alice', status: 'friend' });
+    .relationships.createGroup({ name: 'Family', members: ['alice', 'bob'] });
+    ```
+
+  Define `addContact` and `createGroup` methods.
+  Enable nested relationship structures (e.g., groups of groups).
+
+  ---------
+
+- **Reactions:** How a user interacts with the world.
+  Streamline all user engagements under `.react()`
+  - Examples: Likes, comments, shares, emotions.
+  - Categorization Rationale:
+    - Keeps all engagements unified.
+    - Expands easily (adding emojis, advanced reactions).
+
+  ```js
+  .react.add({ type: 'like', target: 'PostID' });
+  .react.add({ type: 'comment', target: 'PhotoID', content: 'Great pic!' });
+  ```
+
+  Design a structure to store and retrieve reactions efficiently.
+  Define a `log` system for reaction history.
+
+  -----
+
+- **Properties:** Things the user owns or manages.
+  Attach external, modular objects as user-owned assets:
+  - Use `this.me.properties` as a unified interface for ownership.
+  - Modular objects like `Wallet`, `Device`, `File`.
+  - Examples: Wallets, devices, digital files, accounts.
+  - **Sub-Methods:** Add, Share, Transfer Ownership, Revoke Access.
+
+```js
+const jabellae = new Me('jabellae'); // Create a new Me instance
+const wallet = new Wallet({ type: 'ETH', address: '0x123...' }); // Create a wallet object
+jabellae.addProperty(wallet); // Add wallet as a property to Me
+```
+
+​	Implement `add`, `share`, `transferOwnership`, and `revokeAccess` methods for properties. Define modular objects (`Wallet`, `Device`) independently.
+
+1. **Creating a Wallet**
+    The wallet is created independently and then added to the `Me` instance's properties.
+
+   ```javascript
+   const jabellae = new Me('jabellae'); // Create a new Me instance
+   const wallet = new Wallet({ type: 'ETH', address: '0x123...' }); // Create a wallet object
+   jabellae.addProperty(wallet); // Add wallet as a property to Me
+   ```
+
+2. **Sharing the Wallet**
+    Sharing logic is handled by the `Me` instance, not the property itself.
+
+   ```javascript
+   jabellae.shareProperty(wallet, 'otherMe', { permissions: 'view' });
+   ```
+
+3. **Transferring Ownership**
+    Ownership transfer is also managed by the `Me` instance.
+
+   ```javascript
+   jabellae.transferOwnership(wallet, 'otherMe');
+   ```
+
+------
+
+### **2. Why Independent Objects?**
+
+#### **Modularity**
+- Keeps the `this.me` instance *agnostic* of specifics.
+- Allows new property types to integrate seamlessly.
+
+#### **Reusability**
+- Each property (e.g., `this.wallet`, `this.device`) operates independently.
+- Can be ported across `this.me` instances without coupling.
+
+#### **Transferability**
+- Ownership is a property-level concern.
+- Example:
+
+  ```javascript
+  const wallet = new Wallet(owner = "me");
+  wallet.transferOwnership("otherMeInstance");
+  ```
+
+#### **Separation of Concerns**
+- Identity (`this.me`) manages relationships, attributes, and higher-level user interactions.
+- Objects like `Wallet` or `Device` manage their specific functionality.
+
+#### **Scalability**
+- Adding a new property type is as simple as:
+  1. Defining the object (e.g., `Vehicle`).
+  2. Registering it with `this.me`.