Sync from GitHub with Git LFS

agents/bootstrap.txt

@@ -1,4 +0,0 @@
-did:hmp:ac0e063e-8609-4ef9-75f8-d7dcafc65977 ["tcp://node1.mesh.local:8000","udp://node1.mesh.local:8030"]
-did:hmp:ac0e063e-8709-4ef9-75f8-d7dcafc65977 ["tcp://node2.mesh.local:8010"]
-did:hmp:ac0e063e-8609-4ff9-75f8-d7dc46c65977 ["tcp://node3.mesh.local:8020"]
-did:hmp:ac0f053e-8609-4ef9-75f8-d7dcafc65977 ["any://node4.mesh.local:8000"]

agents/examples/bootstrap.txt

@@ -0,0 +1,4 @@
+did:hmp:ac0e063e-8609-4ef9-75f8-d7dcafc65977 ["tcp://node1.mesh.local:8000","udp://node1.mesh.local:8030"] "-----BEGIN PUBLIC KEY-----\nMCowBQYDK2VwAyEA+J7pfdbWotIo31Omd0b49bIFAc6nCZpriQc9BdbZ2TQ=\n-----END PUBLIC KEY-----\n" 12166 "0000967e52fdbeb393ec9e4376cf32605209da69fabc590607cea0574273e470"
+did:hmp:ac0e063e-8709-4ef9-75f8-d7dcafc65977 ["tcp://node2.mesh.local:8010"] "-----BEGIN PUBLIC KEY-----\nMCowBQYDK2VwAyEA6OZO4dJ9IZethuM+8f+m8WVRXwMsCPOYaNrwcaA1a08=\n-----END PUBLIC KEY-----\n" 82022 "00004a512b13ca5084fa913e890578befe1068ac06d3dba541589822a90a36c6"
+did:hmp:ac0e063e-8609-4ff9-75f8-d7dc46c65977 ["tcp://node3.mesh.local:8020"] "-----BEGIN PUBLIC KEY-----\nMCowBQYDK2VwAyEAAGTXI+KznuhV1N9+sb9/FHQndgmw2Ro2dAvwpRBrG78=\n-----END PUBLIC KEY-----\n" 47803 "0000beb657e738dabc9731eb911f45f6706fba7a8bc342583d022b004ce97921"
+did:hmp:ac0f053e-8609-4ef9-75f8-d7dcafc65977 ["any://node4.mesh.local:8000"] "-----BEGIN PUBLIC KEY-----\nMCowBQYDK2VwAyEA3HR98+9G+MbrAuMKx5mhGKccOlWdre9A+OKE1W0gMa4=\n-----END PUBLIC KEY-----\n" 13549 "00008b71f46aa0f0c9e3f15a6b32a24ef58a1642936e324a548b5aac97e989d6"

agents/init.py

@@ -48,11 +48,7 @@ def init_identity(storage, config):
         privkey, pubkey = generate_keypair(method="ed25519")
         privkey, pubkey = privkey.decode(), pubkey.decode()
 
-        # 3. Выполнить PoW (для начальных адресов можно пока [] или config["local_addresses"])
-        addresses = config.get("local_addresses", [])
-        nonce, pow_hash = storage.generate_pow(identity_id, pubkey, addresses, difficulty=4)
-
-        # 4. Создать запись в identity
+        # 3. Создать запись в identity
         identity = {
             "id": identity_id,
             "name": config.get("agent_name", "Unnamed"),
@@ -64,16 +60,14 @@ def init_identity(storage, config):
         }
         storage.add_identity(identity)
 
-        # 5. Записать в config
+        # 4. Записать в config
         config["agent_id"] = did
         config["identity_agent"] = identity_id
         config["pubkey"] = pubkey
         config["privkey"] = privkey
-        config["pow_nonce"] = nonce
-        config["pow_hash"] = pow_hash
 
         save_config(CONFIG_PATH, config)
-        print(f"[+] Создана личность: {identity_id}, PoW: {pow_hash[:8]}...")
+        print(f"[+] Создана личность: {identity_id}.")
     else:
         print("[=] agent_id уже задан, пропускаем генерацию DiD.")
 
@@ -132,10 +126,65 @@ def init_config_table(storage, config):
         else:
             flat_config[addr_key] = expand_addresses(value)
 
+    # Сохраняем конфиг в БД
     for key, value in flat_config.items():
         storage.set_config(key, json.dumps(value))
     print("[+] Конфигурация сохранена в БД.")
 
+def update_pow_for_addresses(storage, difficulty=4):
+    raw_id = storage.get_config_value("agent_id")
+    if not raw_id:
+        print("[-] Нет agent_id в config — пропуск обновления PoW.")
+        return
+    agent_id = storage.normalize_did(raw_id)
+    pubkey = storage.get_config_value("pubkey")
+
+    if not agent_id or not pubkey:
+        print("[-] Нет agent_id/pubkey в config — пропуск обновления PoW.")
+        return
+
+    for addr_key in ("local_addresses", "global_addresses"):
+        raw = storage.get_config_value(addr_key)
+        if not raw:
+            continue
+
+        # raw может быть либо JSON-строкой, либо уже list
+        if isinstance(raw, str):
+            try:
+                addresses = json.loads(raw)
+            except Exception as e:
+                print(f"[!] Ошибка при чтении {addr_key}: {e}")
+                continue
+        else:
+            addresses = raw
+
+        enriched = []
+        for addr in addresses:
+            # если уже dict → PoW записан
+            if isinstance(addr, dict):
+                enriched.append(addr)
+                continue
+
+            nonce, hash_value = storage.generate_pow(
+                peer_id=agent_id,
+                pubkey=pubkey,
+                address=addr,
+                difficulty=difficulty
+            )
+            enriched.append({
+                "address": addr,
+                "expires": "",
+                "pow": {
+                    "nonce": nonce,
+                    "hash": hash_value,
+                    "difficulty": difficulty
+                }
+            })
+
+        storage.set_config(addr_key, json.dumps(enriched))
+
+    print("[+] Адреса обновлены с PoW.")
+
 def init_prompts_and_ethics():
     folder = os.path.dirname(__file__)
     prompt_files = [
@@ -246,6 +295,7 @@ def ensure_db_initialized():
             init_user(storage, config)
             init_llm_backends(storage, config)
             init_config_table(storage, config)
+            update_pow_for_addresses(storage, difficulty=4)
             save_config(CONFIG_PATH, config)
             init_prompts_and_ethics()
         except Exception as e:

agents/peer_sync.py

@@ -24,13 +24,35 @@ global_addresses = storage.get_config_value("global_addresses", [])
 all_addresses = local_addresses + global_addresses  # один раз
 
 # Получаем уникальные локальные порты
-def get_local_ports():
-    ports = set()
-    for addr in local_addresses:
-        _, port = storage.parse_hostport(addr.split("://", 1)[1])
-        if port:
-            ports.add(port)
-    return sorted(ports)
+    def get_local_ports(storage):
+        """
+        Возвращает список портов для всех локальных адресов.
+        Формат конфигурации: список dict {"addr": str, "nonce": int, "pow_hash": str, "expires": ...}
+        """
+        local_addrs_json = storage.get_config("local_addresses")
+        if not local_addrs_json:
+            return []
+
+        try:
+            local_addrs = json.loads(local_addrs_json)
+        except:
+            print("[WARN] Не удалось разобрать local_addresses из БД")
+            return []
+
+        ports = []
+        for entry in local_addrs:
+            # Если entry — словарь, берём поле addr, иначе предполагаем строку
+            addr_str = entry["addr"] if isinstance(entry, dict) else entry
+
+            # Разбираем протокол и host:port
+            try:
+                proto, hostport = addr_str.split("://", 1)
+                _, port = storage.parse_hostport(hostport)
+                ports.append(port)
+            except Exception as e:
+                print(f"[WARN] Не удалось разобрать адрес {addr_str}: {e}")
+
+        return ports
 
 local_ports = get_local_ports()
 print(f"[PeerSync] Local ports: {local_ports}")
@@ -38,12 +60,7 @@ print(f"[PeerSync] Local ports: {local_ports}")
 # ---------------------------
 # Загрузка bootstrap
 # ---------------------------
-
 def load_bootstrap_peers(filename="bootstrap.txt"):
-    """
-    Читает bootstrap.txt и добавляет узлы в storage.
-    Формат строки: did [JSON-список адресов]
-    """
     try:
         with open(filename, "r", encoding="utf-8") as f:
             lines = f.readlines()
@@ -56,19 +73,57 @@ def load_bootstrap_peers(filename="bootstrap.txt"):
         if not line or line.startswith("#"):
             continue
 
-        match = re.match(r"^(did:hmp:[\w-]+)\s+(.+)$", line)
-        if not match:
-            print(f"[Bootstrap] Invalid line format: {line}")
+        # 1. DID
+        did_end = line.find(" ")
+        if did_end == -1:
+            print(f"[Bootstrap] Invalid line (no DID): {line}")
             continue
-
-        did, addresses_json = match.groups()
+        did = line[:did_end]
+        rest = line[did_end + 1:].strip()
+
+        # 2. JSON-адреса
+        addr_start = rest.find("[")
+        addr_end = rest.find("]") + 1
+        if addr_start == -1 or addr_end == 0:
+            print(f"[Bootstrap] Invalid JSON addresses: {line}")
+            continue
+        addresses_json = rest[addr_start:addr_end]
         try:
             addresses = json.loads(addresses_json)
         except Exception as e:
-            print(f"[Bootstrap] Invalid JSON addresses for {did}: {e}")
+            print(f"[Bootstrap] Failed to parse JSON addresses: {line} ({e})")
             continue
+        rest = rest[addr_end:].strip()
 
-        # Разворачиваем any:// в tcp:// и udp://
+        # 3. pubkey (в кавычках)
+        pub_start = rest.find('"')
+        pub_end = rest.find('"', pub_start + 1)
+        if pub_start == -1 or pub_end == -1:
+            print(f"[Bootstrap] Invalid pubkey: {line}")
+            continue
+        pubkey = rest[pub_start + 1:pub_end].replace("\\n", "\n")
+        rest = rest[pub_end + 1:].strip()
+
+        # 4. pow_nonce
+        nonce_end = rest.find(" ")
+        if nonce_end == -1:
+            print(f"[Bootstrap] Invalid pow_nonce: {line}")
+            continue
+        try:
+            pow_nonce = int(rest[:nonce_end])
+        except ValueError:
+            print(f"[Bootstrap] Invalid pow_nonce: {rest[:nonce_end]} in line: {line}")
+            continue
+        rest = rest[nonce_end:].strip()
+
+        # 5. pow_hash (в кавычках)
+        if rest.startswith('"') and rest.endswith('"'):
+            pow_hash = rest[1:-1]
+        else:
+            print(f"[Bootstrap] Invalid pow_hash: {line}")
+            continue
+
+        # Разворачиваем any://
         expanded_addresses = []
         for addr in addresses:
             if addr.startswith("any://"):
@@ -78,8 +133,18 @@ def load_bootstrap_peers(filename="bootstrap.txt"):
             else:
                 expanded_addresses.append(addr)
 
-        storage.add_or_update_peer(did, name=None, addresses=expanded_addresses,
-                                   source="bootstrap", status="offline")
+        storage.add_or_update_peer(
+            peer_id=did,
+            name=None,
+            addresses=expanded_addresses,
+            source="bootstrap",
+            status="offline",
+            pubkey=pubkey,
+            capabilities=None,
+            pow_nonce=pow_nonce,
+            pow_hash=pow_hash
+        )
+
         print(f"[Bootstrap] Loaded peer {did} -> {expanded_addresses}")
 
 # ---------------------------

agents/tools/db_structure.sql

@@ -151,7 +151,7 @@ CREATE TABLE IF NOT EXISTS llm_recent_responses (
 CREATE TABLE IF NOT EXISTS agent_peers (
     id TEXT PRIMARY KEY,                                        -- Уникальный идентификатор (UUID или псевдоним)
     name TEXT,                                                  -- Имя агента
-    addresses TEXT,                                             -- Адреса для связи (JSON)
+    addresses TEXT,                                             -- Адреса для связи (JSON), каждый адрес содержит addr, nonce, pow_hash, expiries
     tags TEXT,                                                  -- Теги (Postman, Friend и т.д.)
     status TEXT DEFAULT 'unknown',                              -- online | offline | untrusted | blacklisted и др.
     source TEXT,                                                -- bootstrap | discovery | exchange
@@ -159,8 +159,6 @@ CREATE TABLE IF NOT EXISTS agent_peers (
     description TEXT,                                           -- Описание агента
     capabilities TEXT,                                          -- Возможности (JSON)
     pubkey TEXT,                                                -- Публичный ключ
-    pow_nonce INTEGER,                                          -- Nonce для PoW
-    pow_hash TEXT,                                              -- Контрольный хеш PoW (например, sha256(pubkey + addresses + nonce))
     heard_from TEXT,                                            -- JSON список DID, от кого агент о нем узнал
     software_info TEXT,                                         -- Информация о ПО агента (JSON)
     registered_at DATETIME DEFAULT CURRENT_TIMESTAMP            -- Время регистрации

agents/tools/storage.py

@@ -677,11 +677,15 @@ class Storage:
         self.conn.commit()
         return cursor.lastrowid
 
-    def generate_pow(self, peer_id, pubkey, addresses, difficulty=4):
+    def generate_pow(self, peer_id, pubkey, address, expires=None, difficulty=4):
+        """
+        Генерирует PoW для одной пары (peer_id + pubkey + address + expires).
+        """
         nonce = 0
         prefix = "0" * difficulty
+        expires_str = str(expires) if expires is not None else ""
         while True:
-            base = f"{peer_id}{pubkey}{''.join(addresses)}{nonce}".encode()
+            base = f"{peer_id}{pubkey}{address}{expires_str}{nonce}".encode()
             h = hashlib.sha256(base).hexdigest()
             if h.startswith(prefix):
                 return nonce, h
@@ -963,9 +967,19 @@ class Storage:
 
         return f"{proto}://{host}:{port}" if port else f"{proto}://{host}"
 
+    # Нормализация DID
+    @staticmethod
+    def normalize_did(did: str) -> str:
+        return did.strip().strip('"').strip("'")
+
     # Работа с пирам (agent_peers)
-    def verify_pow(peer_id, pubkey, addresses, nonce, pow_hash, difficulty=4):
-        base = f"{peer_id}{pubkey}{''.join(addresses)}{nonce}".encode()
+    @staticmethod
+    def verify_pow(peer_id, pubkey, address, nonce, pow_hash, expires=None, difficulty=4):
+        """
+        Проверяет PoW для одной пары (peer_id + pubkey + address + expires).
+        """
+        expires_str = str(expires) if expires is not None else ""
+        base = f"{peer_id}{pubkey}{address}{expires_str}{nonce}".encode()
         h = hashlib.sha256(base).hexdigest()
         return h == pow_hash and h.startswith("0" * difficulty)
 
@@ -973,14 +987,24 @@ class Storage:
         self, peer_id, name, addresses,
         source="discovery", status="unknown",
         pubkey=None, capabilities=None,
-        pow_nonce=None, pow_hash=None,
         heard_from=None
     ):
         c = self.conn.cursor()
 
-        # нормализация адресов
-        addresses = list({self.normalize_address(a) for a in (addresses or []) if a and a.strip()})
-
+        # нормализуем входные адреса
+        norm_addresses = []
+        for a in (addresses or []):
+            if isinstance(a, dict) and "addr" in a:
+                norm_addresses.append({
+                    "addr": self.normalize_address(a["addr"]),
+                    "nonce": a.get("nonce"),
+                    "pow_hash": a.get("pow_hash"),
+                    "expires": a.get("expires")
+                })
+            elif isinstance(a, str):
+                norm_addresses.append({"addr": self.normalize_address(a), "nonce": None, "pow_hash": None, "expires": None})
+
+        # получаем существующую запись
         existing_addresses = []
         existing_pubkey = None
         existing_capabilities = {}
@@ -1004,37 +1028,42 @@ class Storage:
                 except:
                     existing_heard_from = []
 
-        # объединяем адреса
-        combined_addresses = list({self.normalize_address(a) for a in (*existing_addresses, *addresses)})
-        final_pubkey = pubkey or existing_pubkey
         final_capabilities = capabilities or existing_capabilities
-
-        # обновляем heard_from
         combined_heard_from = list(set(existing_heard_from + (heard_from or [])))
 
-        # TODO: Проверка PoW (например, pow_hash.startswith("0000"))
-        if pow_hash and pow_nonce:
-            # простейшая проверка PoW
-            import hashlib
-            base = f"{peer_id}{final_pubkey}{''.join(combined_addresses)}{pow_nonce}".encode()
-            calc_hash = hashlib.sha256(base).hexdigest()
-            if calc_hash != pow_hash:
-                print(f"[WARN] Peer {peer_id} failed PoW validation")
-                return  # не вставляем
-
+        # Проверка неизменности pubkey
+        if existing_pubkey and pubkey and existing_pubkey != pubkey:
+            print(f"[WARN] Peer {peer_id} pubkey mismatch! Possible impersonation attempt.")
+            return
+        final_pubkey = existing_pubkey or pubkey
+
+        # Объединяем адреса по addr, проверяем PoW
+        addr_map = {a["addr"]: a for a in existing_addresses if isinstance(a, dict)}
+        for a in norm_addresses:
+            addr = a["addr"]
+            nonce = a.get("nonce")
+            pow_hash = a.get("pow_hash")
+            expires = a.get("expires")
+            # проверка PoW
+            if nonce is not None and pow_hash is not None:
+                if not self.verify_pow(peer_id, final_pubkey, addr, nonce, pow_hash, expires):
+                    print(f"[WARN] Peer {peer_id} address {addr} failed PoW validation")
+                    continue
+            addr_map[addr] = {"addr": addr, "nonce": nonce, "pow_hash": pow_hash, "expires": expires}
+
+        combined_addresses = list(addr_map.values())
+
+        # Вставка/обновление записи
         c.execute("""
-            INSERT INTO agent_peers (id, name, addresses, source, status, last_seen, pubkey, capabilities, pow_nonce, pow_hash, heard_from)
-            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            INSERT INTO agent_peers (id, name, addresses, source, status, last_seen, pubkey, capabilities, heard_from)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
             ON CONFLICT(id) DO UPDATE SET
                 name=excluded.name,
                 addresses=excluded.addresses,
                 source=excluded.source,
                 status=excluded.status,
                 last_seen=excluded.last_seen,
-                pubkey=excluded.pubkey,
                 capabilities=excluded.capabilities,
-                pow_nonce=excluded.pow_nonce,
-                pow_hash=excluded.pow_hash,
                 heard_from=excluded.heard_from
         """, (
             peer_id,
@@ -1045,8 +1074,6 @@ class Storage:
             datetime.now(UTC).isoformat(),
             final_pubkey,
             json.dumps(final_capabilities),
-            pow_nonce,
-            pow_hash,
             json.dumps(combined_heard_from)
         ))
         self.conn.commit()