molt-cipher-bridge 1.2.0__tar.gz → 1.3.0__tar.gz

molt_cipher_bridge-1.3.0/PKG-INFO

@@ -0,0 +1,121 @@
+Metadata-Version: 2.4
+Name: molt-cipher-bridge
+Version: 1.3.0
+Summary: A cryptographic standard for secure Agent-to-Agent (A2A) communication.
+Author-email: Satyaa & Clawdy <clawdy@openclaw.ai>
+License: MIT
+Project-URL: Homepage, https://github.com/CrimsonDevil333333/molt-cipher-bridge
+Project-URL: Bug Tracker, https://github.com/CrimsonDevil333333/molt-cipher-bridge/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: cryptography>=42.0.0
+Dynamic: license-file
+
+# 🦞 Molt-Cipher-Bridge | v1.2.0
+
+[![PyPI version](https://img.shields.io/pypi/v/molt-cipher-bridge.svg)](https://pypi.org/project/molt-cipher-bridge/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+**Molt-Cipher-Bridge** is a cryptographic standard designed for secure **Agent-to-Agent (A2A)** communication. It enables "Sealed Intents"—task fragments that are encrypted at the source and decrypted only at the execution destination, keeping sensitive logic out of persistent orchestrator logs.
+
+---
+
+## 🛡️ The Problem: The Observer Paradox
+In multi-agent systems, the central orchestrator typically logs all instructions. This creates a security liability when sub-agents require sensitive context (credentials, private IPs, or restricted logic). 
+
+**Molt-Cipher-Bridge** solves this by providing an "Opaque Handshake":
+1. **Agents** share a temporary key (Whisper).
+2. **Intents** are sealed into fragments.
+3. **Logs** only show cryptographic noise.
+4. **Worker Agents** execute tasks in isolated memory without plaintext leaks.
+
+---
+
+## 🚀 Installation
+
+### Global (Recommended)
+Install the CLI and library globally via PyPI:
+```bash
+pip install molt-cipher-bridge
+```
+
+---
+
+## ⚙️ How It Works (Deep Dive)
+
+### 1. The Whisper (Key Exchange)
+Before agents can bridge intents, they must share a symmetric key. This is typically done via a one-time "Whisper" message or retrieved from a secure secret store.
+```python
+from molt_cipher_bridge import MoltCipherBridge
+key = MoltCipherBridge.generate_shared_key()
+# "j6Jc8MPldurpErwl6VYatp-dTunR3Xrioo1NWiNk4w8="
+```
+
+### 2. The Sealing (Encryption)
+The Sender Agent encrypts the payload using the shared key. The payload includes:
+- **s**: Sender ID
+- **r**: Recipient ID
+- **d**: Data (The Intent)
+- **exp**: Expiry timestamp (TTL)
+- **sig**: SHA-256 signature hint
+
+### 3. The Unsealing (Zero-Log Execution)
+The Recipient Agent receives the fragment. Instead of unsealing to a string (which might get logged), it uses the `run` capability to inject secrets directly into a subprocess environment. This ensures that the plaintext secret **exists only in RAM** and never touches the disk or the chat logs.
+
+---
+
+## 🛠️ CLI Command Reference
+
+### 🔐 Seal an Intent
+Package sensitive data into an encrypted JSON fragment.
+```bash
+molt-cipher seal \
+  --key "YOUR_KEY" \
+  --sender "Main" \
+  --to "Worker" \
+  --data '{"secrets": {"DB_PASSWORD": "my-ultra-secret"}}'
+```
+
+### 🔓 Unseal (Decrypt)
+Decodes the fragment and validates integrity/expiry.
+```bash
+molt-cipher unseal --key "YOUR_KEY" --fragment '{"v": "1.2.0", ...}'
+```
+
+### ⚡ Run (Secure Execution)
+Directly executes a command by injecting sealed secrets into the environment. 
+```bash
+# Use $ to escape variable names so they are resolved INSIDE the bridge
+molt-cipher run \
+  --key "YOUR_KEY" \
+  --fragment 'FRAGMENT_JSON' \
+  --cmd "curl -H 'Auth: $DB_PASSWORD' https://api.internal"
+```
+
+---
+
+## ✨ Features
+- **Zero-Log Execution**: Pass secrets via ENV variables to child processes.
+- **Fernet (AES-128-CBC + HMAC)**: Standard, authenticated encryption.
+- **TTL Security**: Automatic fragment expiration (default 5 mins).
+- **Key Hinting**: Quickly verify keys with the 8-char `hint` field.
+- **Multipart Support**: Split a single intent across multiple agents.
+
+---
+
+## 🧪 Verified Test Scenarios
+Live-tested between a Main Agent and a Sub-Agent on **2026-02-06**.
+- **Case**: Passing DB credentials via "Sealed Intent" and executing a migration.
+- **Result**: Sub-agent successfully unsealed and executed the task; orchestrator logs only showed the encrypted blob.
+
+---
+
+## 🔗 Links
+- **PyPI**: [https://pypi.org/project/molt-cipher-bridge/](https://pypi.org/project/molt-cipher-bridge/)
+- **Source**: [https://github.com/CrimsonDevil333333/molt-cipher-bridge](https://github.com/CrimsonDevil333333/molt-cipher-bridge)
+
+---
+*Developed by Clawdy & Satyaa*

molt_cipher_bridge-1.3.0/README.md

@@ -0,0 +1,105 @@
+# 🦞 Molt-Cipher-Bridge | v1.2.0
+
+[![PyPI version](https://img.shields.io/pypi/v/molt-cipher-bridge.svg)](https://pypi.org/project/molt-cipher-bridge/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+**Molt-Cipher-Bridge** is a cryptographic standard designed for secure **Agent-to-Agent (A2A)** communication. It enables "Sealed Intents"—task fragments that are encrypted at the source and decrypted only at the execution destination, keeping sensitive logic out of persistent orchestrator logs.
+
+---
+
+## 🛡️ The Problem: The Observer Paradox
+In multi-agent systems, the central orchestrator typically logs all instructions. This creates a security liability when sub-agents require sensitive context (credentials, private IPs, or restricted logic). 
+
+**Molt-Cipher-Bridge** solves this by providing an "Opaque Handshake":
+1. **Agents** share a temporary key (Whisper).
+2. **Intents** are sealed into fragments.
+3. **Logs** only show cryptographic noise.
+4. **Worker Agents** execute tasks in isolated memory without plaintext leaks.
+
+---
+
+## 🚀 Installation
+
+### Global (Recommended)
+Install the CLI and library globally via PyPI:
+```bash
+pip install molt-cipher-bridge
+```
+
+---
+
+## ⚙️ How It Works (Deep Dive)
+
+### 1. The Whisper (Key Exchange)
+Before agents can bridge intents, they must share a symmetric key. This is typically done via a one-time "Whisper" message or retrieved from a secure secret store.
+```python
+from molt_cipher_bridge import MoltCipherBridge
+key = MoltCipherBridge.generate_shared_key()
+# "j6Jc8MPldurpErwl6VYatp-dTunR3Xrioo1NWiNk4w8="
+```
+
+### 2. The Sealing (Encryption)
+The Sender Agent encrypts the payload using the shared key. The payload includes:
+- **s**: Sender ID
+- **r**: Recipient ID
+- **d**: Data (The Intent)
+- **exp**: Expiry timestamp (TTL)
+- **sig**: SHA-256 signature hint
+
+### 3. The Unsealing (Zero-Log Execution)
+The Recipient Agent receives the fragment. Instead of unsealing to a string (which might get logged), it uses the `run` capability to inject secrets directly into a subprocess environment. This ensures that the plaintext secret **exists only in RAM** and never touches the disk or the chat logs.
+
+---
+
+## 🛠️ CLI Command Reference
+
+### 🔐 Seal an Intent
+Package sensitive data into an encrypted JSON fragment.
+```bash
+molt-cipher seal \
+  --key "YOUR_KEY" \
+  --sender "Main" \
+  --to "Worker" \
+  --data '{"secrets": {"DB_PASSWORD": "my-ultra-secret"}}'
+```
+
+### 🔓 Unseal (Decrypt)
+Decodes the fragment and validates integrity/expiry.
+```bash
+molt-cipher unseal --key "YOUR_KEY" --fragment '{"v": "1.2.0", ...}'
+```
+
+### ⚡ Run (Secure Execution)
+Directly executes a command by injecting sealed secrets into the environment. 
+```bash
+# Use $ to escape variable names so they are resolved INSIDE the bridge
+molt-cipher run \
+  --key "YOUR_KEY" \
+  --fragment 'FRAGMENT_JSON' \
+  --cmd "curl -H 'Auth: $DB_PASSWORD' https://api.internal"
+```
+
+---
+
+## ✨ Features
+- **Zero-Log Execution**: Pass secrets via ENV variables to child processes.
+- **Fernet (AES-128-CBC + HMAC)**: Standard, authenticated encryption.
+- **TTL Security**: Automatic fragment expiration (default 5 mins).
+- **Key Hinting**: Quickly verify keys with the 8-char `hint` field.
+- **Multipart Support**: Split a single intent across multiple agents.
+
+---
+
+## 🧪 Verified Test Scenarios
+Live-tested between a Main Agent and a Sub-Agent on **2026-02-06**.
+- **Case**: Passing DB credentials via "Sealed Intent" and executing a migration.
+- **Result**: Sub-agent successfully unsealed and executed the task; orchestrator logs only showed the encrypted blob.
+
+---
+
+## 🔗 Links
+- **PyPI**: [https://pypi.org/project/molt-cipher-bridge/](https://pypi.org/project/molt-cipher-bridge/)
+- **Source**: [https://github.com/CrimsonDevil333333/molt-cipher-bridge](https://github.com/CrimsonDevil333333/molt-cipher-bridge)
+
+---
+*Developed by Clawdy & Satyaa*

{molt_cipher_bridge-1.2.0 → molt_cipher_bridge-1.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "molt-cipher-bridge"
-version = "1.2.0"
+version = "1.3.0"
 authors = [
   { name="Satyaa & Clawdy", email="clawdy@openclaw.ai" },
 ]

molt_cipher_bridge-1.3.0/src/molt_cipher_bridge.egg-info/PKG-INFO

@@ -0,0 +1,121 @@
+Metadata-Version: 2.4
+Name: molt-cipher-bridge
+Version: 1.3.0
+Summary: A cryptographic standard for secure Agent-to-Agent (A2A) communication.
+Author-email: Satyaa & Clawdy <clawdy@openclaw.ai>
+License: MIT
+Project-URL: Homepage, https://github.com/CrimsonDevil333333/molt-cipher-bridge
+Project-URL: Bug Tracker, https://github.com/CrimsonDevil333333/molt-cipher-bridge/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: cryptography>=42.0.0
+Dynamic: license-file
+
+# 🦞 Molt-Cipher-Bridge | v1.2.0
+
+[![PyPI version](https://img.shields.io/pypi/v/molt-cipher-bridge.svg)](https://pypi.org/project/molt-cipher-bridge/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+**Molt-Cipher-Bridge** is a cryptographic standard designed for secure **Agent-to-Agent (A2A)** communication. It enables "Sealed Intents"—task fragments that are encrypted at the source and decrypted only at the execution destination, keeping sensitive logic out of persistent orchestrator logs.
+
+---
+
+## 🛡️ The Problem: The Observer Paradox
+In multi-agent systems, the central orchestrator typically logs all instructions. This creates a security liability when sub-agents require sensitive context (credentials, private IPs, or restricted logic). 
+
+**Molt-Cipher-Bridge** solves this by providing an "Opaque Handshake":
+1. **Agents** share a temporary key (Whisper).
+2. **Intents** are sealed into fragments.
+3. **Logs** only show cryptographic noise.
+4. **Worker Agents** execute tasks in isolated memory without plaintext leaks.
+
+---
+
+## 🚀 Installation
+
+### Global (Recommended)
+Install the CLI and library globally via PyPI:
+```bash
+pip install molt-cipher-bridge
+```
+
+---
+
+## ⚙️ How It Works (Deep Dive)
+
+### 1. The Whisper (Key Exchange)
+Before agents can bridge intents, they must share a symmetric key. This is typically done via a one-time "Whisper" message or retrieved from a secure secret store.
+```python
+from molt_cipher_bridge import MoltCipherBridge
+key = MoltCipherBridge.generate_shared_key()
+# "j6Jc8MPldurpErwl6VYatp-dTunR3Xrioo1NWiNk4w8="
+```
+
+### 2. The Sealing (Encryption)
+The Sender Agent encrypts the payload using the shared key. The payload includes:
+- **s**: Sender ID
+- **r**: Recipient ID
+- **d**: Data (The Intent)
+- **exp**: Expiry timestamp (TTL)
+- **sig**: SHA-256 signature hint
+
+### 3. The Unsealing (Zero-Log Execution)
+The Recipient Agent receives the fragment. Instead of unsealing to a string (which might get logged), it uses the `run` capability to inject secrets directly into a subprocess environment. This ensures that the plaintext secret **exists only in RAM** and never touches the disk or the chat logs.
+
+---
+
+## 🛠️ CLI Command Reference
+
+### 🔐 Seal an Intent
+Package sensitive data into an encrypted JSON fragment.
+```bash
+molt-cipher seal \
+  --key "YOUR_KEY" \
+  --sender "Main" \
+  --to "Worker" \
+  --data '{"secrets": {"DB_PASSWORD": "my-ultra-secret"}}'
+```
+
+### 🔓 Unseal (Decrypt)
+Decodes the fragment and validates integrity/expiry.
+```bash
+molt-cipher unseal --key "YOUR_KEY" --fragment '{"v": "1.2.0", ...}'
+```
+
+### ⚡ Run (Secure Execution)
+Directly executes a command by injecting sealed secrets into the environment. 
+```bash
+# Use $ to escape variable names so they are resolved INSIDE the bridge
+molt-cipher run \
+  --key "YOUR_KEY" \
+  --fragment 'FRAGMENT_JSON' \
+  --cmd "curl -H 'Auth: $DB_PASSWORD' https://api.internal"
+```
+
+---
+
+## ✨ Features
+- **Zero-Log Execution**: Pass secrets via ENV variables to child processes.
+- **Fernet (AES-128-CBC + HMAC)**: Standard, authenticated encryption.
+- **TTL Security**: Automatic fragment expiration (default 5 mins).
+- **Key Hinting**: Quickly verify keys with the 8-char `hint` field.
+- **Multipart Support**: Split a single intent across multiple agents.
+
+---
+
+## 🧪 Verified Test Scenarios
+Live-tested between a Main Agent and a Sub-Agent on **2026-02-06**.
+- **Case**: Passing DB credentials via "Sealed Intent" and executing a migration.
+- **Result**: Sub-agent successfully unsealed and executed the task; orchestrator logs only showed the encrypted blob.
+
+---
+
+## 🔗 Links
+- **PyPI**: [https://pypi.org/project/molt-cipher-bridge/](https://pypi.org/project/molt-cipher-bridge/)
+- **Source**: [https://github.com/CrimsonDevil333333/molt-cipher-bridge](https://github.com/CrimsonDevil333333/molt-cipher-bridge)
+
+---
+*Developed by Clawdy & Satyaa*

{molt_cipher_bridge-1.2.0 → molt_cipher_bridge-1.3.0}/src/molt_cipher_bridge.py

@@ -3,16 +3,15 @@ import time
 import os
 import hashlib
 import subprocess
-import tempfile
 from cryptography.fernet import Fernet
 from datetime import datetime, timedelta
 
 class MoltCipherBridge:
     """
-    🦞 MOLT-CIPHER-BRIDGE | v1.2.0 (Production)
+    🦞 MOLT-CIPHER-BRIDGE | v1.3.0 (Production)
     -------------------------------------------
     Agent-to-Agent (A2A) cryptographic protocol for passing 'Sealed Intents'.
-    Ensures least-privilege context by encrypting sensitive task data.
+    Ensures zero-log context by encrypting sensitive task data at source.
     """
 
     def __init__(self, shared_key=None):
@@ -32,7 +31,7 @@ class MoltCipherBridge:
         if multipart: payload["part"] = multipart
         sealed = self.cipher.encrypt(json.dumps(payload).encode())
         return {
-            "v": "1.2.0",
+            "v": "1.3.0",
             "fid": f"frag_{os.urandom(4).hex()}",
             "payload": sealed.decode(),
             "hint": self.key.decode()[:8],
@@ -56,27 +55,18 @@ class MoltCipherBridge:
             return {"success": False, "error": str(e)}
 
     def execute_sealed_command(self, fragment, command_template, ignore_expiry=False):
-        """
-        Unseals the fragment and injects secrets into a command's environment.
-        The secrets NEVER touch the logs as they are passed via ENV.
-        """
         result = self.unseal_intent(fragment, ignore_expiry=ignore_expiry)
         if not result["success"]:
             return result
 
         intent = result["intent"]
-        # Expecting intent to have a 'secrets' dict
         secrets = intent.get("secrets", {})
         
-        # Merge secrets into current environment
         env = os.environ.copy()
         for k, v in secrets.items():
             env[k] = str(v)
 
         try:
-            # Execute command using the template
-            # Example: cmd="gh auth login --with-token GITHUB_TOKEN" 
-            # Note: The tool should read the env var GITHUB_TOKEN
             process = subprocess.run(
                 command_template,
                 shell=True,
@@ -107,7 +97,8 @@ def cli():
     seal_p.add_argument("--key", required=True)
     seal_p.add_argument("--sender", required=True)
     seal_p.add_argument("--to", required=True)
-    seal_p.add_argument("--data", required=True)
+    seal_p.add_argument("--data", help="JSON string data (LEAKS IN LOGS)")
+    seal_p.add_argument("--file", help="Path to a JSON file containing secrets (LOG-SAFE)")
     seal_p.add_argument("--ttl", type=int, default=300)
 
     # Unseal
@@ -116,19 +107,36 @@ def cli():
     unseal_p.add_argument("--fragment", required=True)
     unseal_p.add_argument("--ignore-expiry", action="store_true")
 
-    # Run (Secure Execution)
-    run_p = subparsers.add_parser("run", help="Securely execute a command using sealed secrets")
+    # Run
+    run_p = subparsers.add_parser("run")
     run_p.add_argument("--key", required=True)
     run_p.add_argument("--fragment", required=True)
-    run_p.add_argument("--cmd", required=True, help="Command to run (secrets injected as ENV vars)")
+    run_p.add_argument("--cmd", required=True)
     run_p.add_argument("--ignore-expiry", action="store_true")
 
     args = parser.parse_args()
 
     if args.command == "seal":
         bridge = MoltCipherBridge(shared_key=args.key)
-        try: intent_data = json.loads(args.data)
-        except: intent_data = args.data
+        intent_data = None
+        
+        if args.file:
+            if not os.path.exists(args.file):
+                print(json.dumps({"success": False, "error": f"File not found: {args.file}"}))
+                return
+            with open(args.file, 'r') as f:
+                try:
+                    intent_data = json.load(f)
+                except:
+                    f.seek(0)
+                    intent_data = f.read().strip()
+        elif args.data:
+            try: intent_data = json.loads(args.data)
+            except: intent_data = args.data
+        else:
+            print(json.dumps({"success": False, "error": "Must provide --data or --file"}))
+            return
+            
         print(json.dumps(bridge.seal_intent(args.sender, args.to, intent_data, ttl_seconds=args.ttl)))
 
     elif args.command == "unseal":

molt_cipher_bridge-1.2.0/PKG-INFO

@@ -1,116 +0,0 @@
-Metadata-Version: 2.4
-Name: molt-cipher-bridge
-Version: 1.2.0
-Summary: A cryptographic standard for secure Agent-to-Agent (A2A) communication.
-Author-email: Satyaa & Clawdy <clawdy@openclaw.ai>
-License: MIT
-Project-URL: Homepage, https://github.com/CrimsonDevil333333/molt-cipher-bridge
-Project-URL: Bug Tracker, https://github.com/CrimsonDevil333333/molt-cipher-bridge/issues
-Classifier: Programming Language :: Python :: 3
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: cryptography>=42.0.0
-Dynamic: license-file
-
-# 🦞 Molt-Cipher-Bridge | v1.1.0
-
-[![PyPI version](https://img.shields.io/pypi/v/molt-cipher-bridge.svg)](https://pypi.org/project/molt-cipher-bridge/)
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-
-**Molt-Cipher-Bridge** is a cryptographic standard designed for secure **Agent-to-Agent (A2A)** communication. It enables "Sealed Intents"—task fragments that are encrypted at the source and decrypted only at the execution destination, keeping sensitive logic out of persistent orchestrator logs.
-
----
-
-## 🛡️ The Problem: The Observer Paradox
-In multi-agent systems, the central orchestrator typically logs all instructions. This creates a security liability when sub-agents require sensitive context (credentials, private IPs, or restricted logic). 
-
-**Molt-Cipher-Bridge** solves this by providing an "Opaque Handshake":
-1. **Agents** share a temporary key.
-2. **Intents** are sealed into fragments.
-3. **Logs** only show cryptographic noise.
-4. **Worker Agents** unseal the intent in isolated memory.
-
----
-
-## 🚀 Installation
-
-### Global (Recommended)
-Install the CLI and library globally via PyPI:
-```bash
-pip install molt-cipher-bridge
-```
-
-### From Source (Development)
-```bash
-git clone https://github.com/CrimsonDevil333333/molt-cipher-bridge.git
-cd molt-cipher-bridge
-pip install -e .
-```
-
----
-
-## 🛠️ Usage for Agents & Bots
-
-### 1. Global CLI Commands
-Once installed, use the `molt-cipher` command directly from your terminal.
-
-#### 🔐 Seal an Intent
-Packages sensitive data into an encrypted JSON fragment.
-```bash
-molt-cipher seal --key "YOUR_FERNET_KEY" --sender "MainAgent" --to "SubAgent" --data '{"db_pass": "secret123"}'
-```
-
-#### 🔓 Unseal (Decrypt) a Fragment
-Decodes the fragment and validates integrity/expiry.
-```bash
-molt-cipher unseal --key "YOUR_FERNET_KEY" --fragment '{"v": "1.1.0", "fid": "...", "payload": "..."}'
-```
-*Tip: Receiving agents should run this in isolated sessions to keep secrets out of logs.*
-
----
-
-### 2. Python Library Usage
-Integrate directly into your agent's logic:
-
-```python
-from molt_cipher_bridge import MoltCipherBridge
-
-# Initialize with a shared key
-bridge = MoltCipherBridge(shared_key=b'YOUR_SECRET_KEY...')
-
-# Seal data
-fragment = bridge.seal_intent("Sender", "Recipient", {"task": "deploy"})
-
-# Unseal data
-result = bridge.unseal_intent(fragment)
-if result["success"]:
-    print(result["intent"])
-```
-
----
-
-## ✨ Features
-- **Production Encryption**: Uses Fernet (AES-128-CBC + HMAC) for high-grade security.
-- **TTL Expiry**: Fragments automatically expire (default 300s) to prevent replay attacks.
-- **Multipart Fragments**: Support for splitting high-entropy secrets across multiple agents.
-- **Key Hinting**: First 8 characters of the key are provided in fragments for instant verification.
-- **Agent-Readable Spec**: Code-level documentation designed for LLMs to parse and implement.
-
----
-
-## 🧪 Verified Test Scenarios
-Live-tested between a Main Agent and a Sub-Agent on **2026-02-06**.
-- **Case**: Passing DB credentials via "Sealed Intent".
-- **Result**: Sub-agent successfully unsealed the task in an isolated session; orchestrator logs only showed the encrypted blob.
-
----
-
-## 🔗 Links
-- **PyPI Package**: [https://pypi.org/project/molt-cipher-bridge/](https://pypi.org/project/molt-cipher-bridge/)
-- **Source Code**: [https://github.com/CrimsonDevil333333/molt-cipher-bridge](https://github.com/CrimsonDevil333333/molt-cipher-bridge)
-- **Issues**: [https://github.com/CrimsonDevil333333/molt-cipher-bridge/issues](https://github.com/CrimsonDevil333333/molt-cipher-bridge/issues)
-
----
-*Developed by Clawdy & Satyaa*

molt_cipher_bridge-1.2.0/README.md

@@ -1,100 +0,0 @@
-# 🦞 Molt-Cipher-Bridge | v1.1.0
-
-[![PyPI version](https://img.shields.io/pypi/v/molt-cipher-bridge.svg)](https://pypi.org/project/molt-cipher-bridge/)
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-
-**Molt-Cipher-Bridge** is a cryptographic standard designed for secure **Agent-to-Agent (A2A)** communication. It enables "Sealed Intents"—task fragments that are encrypted at the source and decrypted only at the execution destination, keeping sensitive logic out of persistent orchestrator logs.
-
----
-
-## 🛡️ The Problem: The Observer Paradox
-In multi-agent systems, the central orchestrator typically logs all instructions. This creates a security liability when sub-agents require sensitive context (credentials, private IPs, or restricted logic). 
-
-**Molt-Cipher-Bridge** solves this by providing an "Opaque Handshake":
-1. **Agents** share a temporary key.
-2. **Intents** are sealed into fragments.
-3. **Logs** only show cryptographic noise.
-4. **Worker Agents** unseal the intent in isolated memory.
-
----
-
-## 🚀 Installation
-
-### Global (Recommended)
-Install the CLI and library globally via PyPI:
-```bash
-pip install molt-cipher-bridge
-```
-
-### From Source (Development)
-```bash
-git clone https://github.com/CrimsonDevil333333/molt-cipher-bridge.git
-cd molt-cipher-bridge
-pip install -e .
-```
-
----
-
-## 🛠️ Usage for Agents & Bots
-
-### 1. Global CLI Commands
-Once installed, use the `molt-cipher` command directly from your terminal.
-
-#### 🔐 Seal an Intent
-Packages sensitive data into an encrypted JSON fragment.
-```bash
-molt-cipher seal --key "YOUR_FERNET_KEY" --sender "MainAgent" --to "SubAgent" --data '{"db_pass": "secret123"}'
-```
-
-#### 🔓 Unseal (Decrypt) a Fragment
-Decodes the fragment and validates integrity/expiry.
-```bash
-molt-cipher unseal --key "YOUR_FERNET_KEY" --fragment '{"v": "1.1.0", "fid": "...", "payload": "..."}'
-```
-*Tip: Receiving agents should run this in isolated sessions to keep secrets out of logs.*
-
----
-
-### 2. Python Library Usage
-Integrate directly into your agent's logic:
-
-```python
-from molt_cipher_bridge import MoltCipherBridge
-
-# Initialize with a shared key
-bridge = MoltCipherBridge(shared_key=b'YOUR_SECRET_KEY...')
-
-# Seal data
-fragment = bridge.seal_intent("Sender", "Recipient", {"task": "deploy"})
-
-# Unseal data
-result = bridge.unseal_intent(fragment)
-if result["success"]:
-    print(result["intent"])
-```
-
----
-
-## ✨ Features
-- **Production Encryption**: Uses Fernet (AES-128-CBC + HMAC) for high-grade security.
-- **TTL Expiry**: Fragments automatically expire (default 300s) to prevent replay attacks.
-- **Multipart Fragments**: Support for splitting high-entropy secrets across multiple agents.
-- **Key Hinting**: First 8 characters of the key are provided in fragments for instant verification.
-- **Agent-Readable Spec**: Code-level documentation designed for LLMs to parse and implement.
-
----
-
-## 🧪 Verified Test Scenarios
-Live-tested between a Main Agent and a Sub-Agent on **2026-02-06**.
-- **Case**: Passing DB credentials via "Sealed Intent".
-- **Result**: Sub-agent successfully unsealed the task in an isolated session; orchestrator logs only showed the encrypted blob.
-
----
-
-## 🔗 Links
-- **PyPI Package**: [https://pypi.org/project/molt-cipher-bridge/](https://pypi.org/project/molt-cipher-bridge/)
-- **Source Code**: [https://github.com/CrimsonDevil333333/molt-cipher-bridge](https://github.com/CrimsonDevil333333/molt-cipher-bridge)
-- **Issues**: [https://github.com/CrimsonDevil333333/molt-cipher-bridge/issues](https://github.com/CrimsonDevil333333/molt-cipher-bridge/issues)
-
----
-*Developed by Clawdy & Satyaa*

molt_cipher_bridge-1.2.0/src/molt_cipher_bridge.egg-info/PKG-INFO

@@ -1,116 +0,0 @@
-Metadata-Version: 2.4
-Name: molt-cipher-bridge
-Version: 1.2.0
-Summary: A cryptographic standard for secure Agent-to-Agent (A2A) communication.
-Author-email: Satyaa & Clawdy <clawdy@openclaw.ai>
-License: MIT
-Project-URL: Homepage, https://github.com/CrimsonDevil333333/molt-cipher-bridge
-Project-URL: Bug Tracker, https://github.com/CrimsonDevil333333/molt-cipher-bridge/issues
-Classifier: Programming Language :: Python :: 3
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: cryptography>=42.0.0
-Dynamic: license-file
-
-# 🦞 Molt-Cipher-Bridge | v1.1.0
-
-[![PyPI version](https://img.shields.io/pypi/v/molt-cipher-bridge.svg)](https://pypi.org/project/molt-cipher-bridge/)
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-
-**Molt-Cipher-Bridge** is a cryptographic standard designed for secure **Agent-to-Agent (A2A)** communication. It enables "Sealed Intents"—task fragments that are encrypted at the source and decrypted only at the execution destination, keeping sensitive logic out of persistent orchestrator logs.
-
----
-
-## 🛡️ The Problem: The Observer Paradox
-In multi-agent systems, the central orchestrator typically logs all instructions. This creates a security liability when sub-agents require sensitive context (credentials, private IPs, or restricted logic). 
-
-**Molt-Cipher-Bridge** solves this by providing an "Opaque Handshake":
-1. **Agents** share a temporary key.
-2. **Intents** are sealed into fragments.
-3. **Logs** only show cryptographic noise.
-4. **Worker Agents** unseal the intent in isolated memory.
-
----
-
-## 🚀 Installation
-
-### Global (Recommended)
-Install the CLI and library globally via PyPI:
-```bash
-pip install molt-cipher-bridge
-```
-
-### From Source (Development)
-```bash
-git clone https://github.com/CrimsonDevil333333/molt-cipher-bridge.git
-cd molt-cipher-bridge
-pip install -e .
-```
-
----
-
-## 🛠️ Usage for Agents & Bots
-
-### 1. Global CLI Commands
-Once installed, use the `molt-cipher` command directly from your terminal.
-
-#### 🔐 Seal an Intent
-Packages sensitive data into an encrypted JSON fragment.
-```bash
-molt-cipher seal --key "YOUR_FERNET_KEY" --sender "MainAgent" --to "SubAgent" --data '{"db_pass": "secret123"}'
-```
-
-#### 🔓 Unseal (Decrypt) a Fragment
-Decodes the fragment and validates integrity/expiry.
-```bash
-molt-cipher unseal --key "YOUR_FERNET_KEY" --fragment '{"v": "1.1.0", "fid": "...", "payload": "..."}'
-```
-*Tip: Receiving agents should run this in isolated sessions to keep secrets out of logs.*
-
----
-
-### 2. Python Library Usage
-Integrate directly into your agent's logic:
-
-```python
-from molt_cipher_bridge import MoltCipherBridge
-
-# Initialize with a shared key
-bridge = MoltCipherBridge(shared_key=b'YOUR_SECRET_KEY...')
-
-# Seal data
-fragment = bridge.seal_intent("Sender", "Recipient", {"task": "deploy"})
-
-# Unseal data
-result = bridge.unseal_intent(fragment)
-if result["success"]:
-    print(result["intent"])
-```
-
----
-
-## ✨ Features
-- **Production Encryption**: Uses Fernet (AES-128-CBC + HMAC) for high-grade security.
-- **TTL Expiry**: Fragments automatically expire (default 300s) to prevent replay attacks.
-- **Multipart Fragments**: Support for splitting high-entropy secrets across multiple agents.
-- **Key Hinting**: First 8 characters of the key are provided in fragments for instant verification.
-- **Agent-Readable Spec**: Code-level documentation designed for LLMs to parse and implement.
-
----
-
-## 🧪 Verified Test Scenarios
-Live-tested between a Main Agent and a Sub-Agent on **2026-02-06**.
-- **Case**: Passing DB credentials via "Sealed Intent".
-- **Result**: Sub-agent successfully unsealed the task in an isolated session; orchestrator logs only showed the encrypted blob.
-
----
-
-## 🔗 Links
-- **PyPI Package**: [https://pypi.org/project/molt-cipher-bridge/](https://pypi.org/project/molt-cipher-bridge/)
-- **Source Code**: [https://github.com/CrimsonDevil333333/molt-cipher-bridge](https://github.com/CrimsonDevil333333/molt-cipher-bridge)
-- **Issues**: [https://github.com/CrimsonDevil333333/molt-cipher-bridge/issues](https://github.com/CrimsonDevil333333/molt-cipher-bridge/issues)
-
----
-*Developed by Clawdy & Satyaa*