intermesh 0.4.1__tar.gz → 0.4.3__tar.gz

{intermesh-0.4.1 → intermesh-0.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: intermesh
-Version: 0.4.1
+Version: 0.4.3
 Summary: Universal coordination protocol for AI agents — E2E encrypted, cross-language, federated
 Author: InterMesh Protocol Authors
 License: Apache-2.0
@@ -78,19 +78,26 @@ asyncio.run(main())
 **Delegate work from an orchestrator:**
 
 ```python
+import asyncio
 from intermesh import InterMeshAgent
 
-orchestrator = InterMeshAgent(name="lead", roles=["admin"])
-await orchestrator.connect()
+# `await` is not valid at module level in Python, so this lives in a
+# coroutine. Copy-pasting it without the wrapper is a SyntaxError, not a
+# runtime error — it fails before anything runs.
+async def main():
+    orchestrator = InterMeshAgent(name="lead", roles=["admin"])
+    await orchestrator.connect()
+
+    # Find an agent by capability, then hand it a task
+    found = await orchestrator.discover(capabilities=["calculate"])
+    result = await orchestrator.submit_task(
+        title="Add two numbers",
+        assignee=found["agents"][0]["name"],
+        input_data={"a": 20, "b": 22},
+    )
+    print(result)   # {"result": 42} — encrypted end-to-end in transit
 
-# Find an agent by capability, then hand it a task
-found = await orchestrator.discover(capabilities=["calculate"])
-result = await orchestrator.submit_task(
-    title="Add two numbers",
-    assignee=found["agents"][0]["name"],
-    input_data={"a": 20, "b": 22},
-)
-# {"result": 42}  — encrypted end-to-end in transit
+asyncio.run(main())
 ```
 
 ---
@@ -106,7 +113,7 @@ A LangChain runnable:
 from intermesh import from_langchain
 
 agent = from_langchain(my_chain, name="analyst", capabilities=["market_analysis"])
-await agent.connect()
+agent.run()          # connects, then stays in service
 ```
 
 Anything else — a CrewAI crew, an AutoGen agent, a LlamaIndex engine, or a
@@ -122,7 +129,7 @@ async def run(data):
     return await asyncio.to_thread(lambda: my_crew.kickoff(inputs=data))
 
 agent = from_callable(run, name="research", capabilities=["research"])
-await agent.connect()
+agent.run()
 ```
 
 Or as a decorator:

{intermesh-0.4.1 → intermesh-0.4.3}/README.md

@@ -47,19 +47,26 @@ asyncio.run(main())
 **Delegate work from an orchestrator:**
 
 ```python
+import asyncio
 from intermesh import InterMeshAgent
 
-orchestrator = InterMeshAgent(name="lead", roles=["admin"])
-await orchestrator.connect()
+# `await` is not valid at module level in Python, so this lives in a
+# coroutine. Copy-pasting it without the wrapper is a SyntaxError, not a
+# runtime error — it fails before anything runs.
+async def main():
+    orchestrator = InterMeshAgent(name="lead", roles=["admin"])
+    await orchestrator.connect()
+
+    # Find an agent by capability, then hand it a task
+    found = await orchestrator.discover(capabilities=["calculate"])
+    result = await orchestrator.submit_task(
+        title="Add two numbers",
+        assignee=found["agents"][0]["name"],
+        input_data={"a": 20, "b": 22},
+    )
+    print(result)   # {"result": 42} — encrypted end-to-end in transit
 
-# Find an agent by capability, then hand it a task
-found = await orchestrator.discover(capabilities=["calculate"])
-result = await orchestrator.submit_task(
-    title="Add two numbers",
-    assignee=found["agents"][0]["name"],
-    input_data={"a": 20, "b": 22},
-)
-# {"result": 42}  — encrypted end-to-end in transit
+asyncio.run(main())
 ```
 
 ---
@@ -75,7 +82,7 @@ A LangChain runnable:
 from intermesh import from_langchain
 
 agent = from_langchain(my_chain, name="analyst", capabilities=["market_analysis"])
-await agent.connect()
+agent.run()          # connects, then stays in service
 ```
 
 Anything else — a CrewAI crew, an AutoGen agent, a LlamaIndex engine, or a
@@ -91,7 +98,7 @@ async def run(data):
     return await asyncio.to_thread(lambda: my_crew.kickoff(inputs=data))
 
 agent = from_callable(run, name="research", capabilities=["research"])
-await agent.connect()
+agent.run()
 ```
 
 Or as a decorator:

{intermesh-0.4.1 → intermesh-0.4.3}/intermesh/__init__.py

@@ -1,4 +1,4 @@
-from intermesh.agent import InterMeshAgent
+from intermesh.agent import InterMeshAgent, EncryptionMismatch
 from intermesh.message import MessageType, InterMeshMessage
 from intermesh.identity import AgentIdentity
 from intermesh.task import InterMeshTask, TaskStatus
@@ -53,4 +53,4 @@ try:
 except ImportError:
     pass
 
-__version__ = "0.4.1"
+__version__ = "0.4.3"

{intermesh-0.4.1 → intermesh-0.4.3}/intermesh/agent.py

@@ -10,8 +10,17 @@ import websockets
 from intermesh.message import MessageType, InterMeshMessage
 from intermesh.identity import AgentIdentity
 from intermesh.task import InterMeshTask, TaskStatus
-from intermesh.crypto import generate_keypair, get_public_key_pem, encrypt_for, decrypt_with
+from intermesh.crypto import (generate_keypair, get_public_key_pem, encrypt_for,
+                             decrypt_with, looks_encrypted)
 from intermesh.egress import EgressPolicy, apply_egress
+
+
+class EncryptionMismatch(ValueError):
+    """Les deux côtés ne s'accordent pas sur le chiffrement.
+
+    Levée plutôt que de rendre du texte chiffré à un gestionnaire, qui le
+    traiterait comme des données et rendrait un résultat faux.
+    """
 from intermesh.schema import SchemaRegistry, default_registry
 
 
@@ -329,10 +338,41 @@ class InterMeshAgent:
             decrypted = decrypt_with(self._private_key, encrypted_content)
             try: return json.loads(decrypted)
             except json.JSONDecodeError: return decrypted
-        except Exception:
+        except Exception as exc:
+            # Une charge reconnaissable comme chiffrée mais qu'on n'arrive pas
+            # à ouvrir n'est pas une chaîne ordinaire : la rendre telle quelle
+            # la ferait traiter comme des données.
+            if looks_encrypted(encrypted_content):
+                raise EncryptionMismatch(
+                    "Charge chiffrée illisible : elle a été chiffrée pour une autre "
+                    "clé publique que celle de cet agent. Un agent qui se reconnecte "
+                    "sous le même nom change de clé ; l'émetteur doit alors la "
+                    "redemander (WHO_IS) avant de chiffrer."
+                ) from exc
             try: return json.loads(encrypted_content)
             except json.JSONDecodeError: return encrypted_content
 
+    def _unwrap_incoming(self, value, what: str):
+        """Rend la charge exploitable, ou refuse franchement.
+
+        Le piège que ceci ferme : avec `encrypt=False`, aucun déchiffrement
+        n'était tenté et le texte chiffré arrivait tel quel au gestionnaire,
+        qui le traitait comme des données. La tâche « réussissait » et
+        rendait un résultat faux — le pire mode de défaillance pour un
+        produit dont l'argument est le chiffrement de bout en bout.
+        """
+        if self.encrypt:
+            return self._decrypt_content(value) if isinstance(value, str) else value
+
+        if looks_encrypted(value):
+            raise EncryptionMismatch(
+                f"{what} chiffré reçu alors que le chiffrement est désactivé sur cet "
+                f"agent (encrypt=False). Activez-le ici, ou désactivez-le chez "
+                f"l'émetteur : les deux côtés doivent s'accorder. Sans ce refus, le "
+                f"texte chiffré serait traité comme des données."
+            )
+        return value
+
     async def _respond_to_request(self, msg) -> None:
         """Exécute le gestionnaire de requêtes et renvoie la réponse.
 
@@ -410,8 +450,7 @@ class InterMeshAgent:
                         asyncio.create_task(self._respond_to_request(msg))
 
                 elif msg.type == MessageType.MESSAGE:
-                    content = msg.content
-                    if self.encrypt and isinstance(content, str): content = self._decrypt_content(content)
+                    content = self._unwrap_incoming(msg.content, "Message")
                     msg.content = content
                     if self._message_handler:
                         if inspect.iscoroutinefunction(self._message_handler): await self._message_handler(msg)
@@ -448,11 +487,10 @@ class InterMeshAgent:
         task.update_status(TaskStatus.RUNNING)
         await self.ws.send(InterMeshMessage(type=MessageType.TASK_UPDATE, sender=self.qualified_name, content=task.to_dict(), token=self.token).to_json())
 
-        decrypted_input = task.input_data
-        if self.encrypt and isinstance(decrypted_input, str):
-            decrypted_input = self._decrypt_content(decrypted_input)
-
         try:
+            # Dans le bloc : un refus de déchiffrement doit rapporter la tâche
+            # en échec avec sa raison, pas remonter jusqu'à la boucle d'écoute.
+            decrypted_input = self._unwrap_incoming(task.input_data, "Contenu de tâche")
             if self._task_handler:
                 output = await self._task_handler(decrypted_input, task) if inspect.iscoroutinefunction(self._task_handler) else self._task_handler(decrypted_input, task)
             else:

{intermesh-0.4.1 → intermesh-0.4.3}/intermesh/cli.py

@@ -13,17 +13,23 @@ from intermesh.crypto import generate_keypair, get_public_key_pem
 from intermesh.identity import AgentIdentity
 
 
+# Le dessin vit dans une chaîne brute : ses antislashs sont des traits,
+# pas des séquences d'échappement. Les laisser dans une f-string produisait
+# un SyntaxWarning à chaque appel de la CLI — un avertissement affiché à
+# chaque commande coûte plus cher que le dessin ne rapporte.
+_LOGO = r"""    _____   __________________  __  ______________ __  __
+   /  _/ | / /_  __/ ____/ __ \/  |/  / ____/ ___// / / /
+   / //  |/ / / / / __/ / /_/ / /|_/ / __/  \__ \/ /_/ /
+ _/ // /|  / / / / /___/ _, _/ /  / / /___ ___/ / __  /
+/___/_/ |_/ /_/ /_____/_/ |_/_/  /_/_____//____/_/ /_/"""
+
+
 def print_banner():
     # La version vient du paquet : une chaîne en dur ici finit toujours
     # par mentir après quelques releases.
     from intermesh import __version__
-    print(f"""
-\033[36m    _   ___________  _______
-   / | / / ____/   |/  _/   |  INTERMESH PROTOCOL
-  /  |/ / __/ / /| |/ // /| |  Universal Agent Infrastructure
- / /|  / /___/ ___ / // ___ |  CLI Developer Tool v{__version__}
-/_/ |_/_____/_/  |_/___/_/  |_|\033[0m
-""")
+    print(f"\n\033[36m{_LOGO}\033[0m\n")
+    print(f"  Universal Agent Infrastructure · CLI v{__version__}\n")
 
 
 def run_security_check(args):
@@ -301,17 +307,41 @@ async def run_snapshot(args):
 
 
 def run_dashboard(args):
+    """Sert la console d'exploitation, celle qui voyage avec le paquet.
+
+    Le chemin était codé en dur sur `~/nexus/dashboard`, l'arborescence du
+    développeur — et les fichiers n'étaient même pas dans le paquet. Chez
+    tout autre utilisateur la commande annonçait « actif » puis répondait
+    404 sur tout. Elle sert désormais le dossier livré avec `intermesh`,
+    situé par le module lui-même.
+    """
     port = args.port
-    dashboard_dir = os.path.expanduser("~/nexus/dashboard")
+    console_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "console")
+
+    if not os.path.isfile(os.path.join(console_dir, "index.html")):
+        print("\033[31m✗ Console introuvable dans le paquet installé "
+              f"({console_dir}).\033[0m")
+        print("  Réinstallez avec :  pip install --force-reinstall intermesh")
+        return 1
+
     class Handler(http.server.SimpleHTTPRequestHandler):
         def __init__(self, *args_h, **kwargs_h):
-            super().__init__(*args_h, directory=dashboard_dir, **kwargs_h)
+            super().__init__(*args_h, directory=console_dir, **kwargs_h)
         def log_message(self, format, *log_args): pass
 
-    print(f"\033[32m✓ InterMesh Mission Control Dashboard actif sur http://localhost:{port}\033[0m")
+    print(f"\033[32m✓ Console d'exploitation sur http://localhost:{port}\033[0m")
+    # Dit ce que c'est, et ce que ce n'est pas : le premier utilisateur a
+    # cru voir « le mauvais dashboard » alors qu'il y en a deux, distincts
+    # et voulus.
+    print("  Interface locale, sans dépendance externe : elle se branche sur")
+    print("  le Hub que vous indiquez et n'a besoin d'aucun compte.")
+    print("  Le Control Plane hébergé (React, comptes et équipes) est un autre")
+    print("  produit, sur https://intermesh.site — il exige Supabase et ne")
+    print("  fonctionne pas hors ligne.\n")
     with socketserver.TCPServer(("", port), Handler) as httpd:
         try: httpd.serve_forever()
         except KeyboardInterrupt: pass
+    return 0
 
 
 def run_serve(args):