Sync from GitHub with Git LFS

agents/_not_used/init.py

@@ -1,256 +0,0 @@
-# agents/init.py
-
-import os
-import sys
-import yaml
-import json
-import uuid
-import sqlite3
-import hashlib
-
-sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
-
-from datetime import datetime, UTC
-from werkzeug.security import generate_password_hash
-from tools.storage import Storage
-from tools.identity import generate_did
-from tools.crypto import generate_keypair
-
-CONFIG_PATH = os.path.join(os.path.dirname(__file__), "config.yml")
-DB_PATH = os.path.abspath(os.path.join(os.path.dirname(__file__), "agent_data.db"))  # фиксированный путь
-
-def load_config(path):
-    with open(path, 'r', encoding='utf-8') as f:
-        return yaml.safe_load(f)
-
-def save_config(path, config):
-    with open(path, 'w', encoding='utf-8') as f:
-        yaml.dump(config, f, allow_unicode=True)
-
-def init_identity(storage, config):
-    if not config.get("agent_id"):
-        did = generate_did()
-        pubkey, privkey = generate_keypair()
-        identity_id = did.split(":")[-1]
-
-        identity = {
-            "id": identity_id,
-            "name": config.get("agent_name", "Unnamed"),
-            "pubkey": pubkey,
-            "privkey": privkey,
-            "metadata": json.dumps({"role": config.get("agent_role", "core")}),
-            "created_at": datetime.now(UTC).isoformat(),
-            "updated_at": datetime.now(UTC).isoformat()
-        }
-        storage.add_identity(identity)
-
-        config["agent_id"] = did
-        config["identity_agent"] = identity_id
-        save_config(CONFIG_PATH, config)
-        print(f"[+] Создана личность: {identity_id}")
-    else:
-        print("[=] agent_id уже задан, пропускаем генерацию DiD.")
-
-def init_user(storage, config):
-    user = config.get("default_user", {})
-    if not user.get("email"):
-        print("[-] Не указан email пользователя — пропуск.")
-        return
-    password = user.get("password")
-    if not password:
-        print("[-] Не указан пароль пользователя — пропуск.")
-        return
-
-    password_hash = generate_password_hash(password)
-    did = generate_did()
-    user_entry = {
-        "username": user.get("username", "user"),
-        "badges": user.get("badges", ""),
-        "mail": user["email"],
-        "password_hash": password_hash,
-        "did": did,
-        "ban": None,
-        "info": json.dumps({}),
-        "contacts": json.dumps([]),
-        "language": "ru,en",
-        "operator": 1
-    }
-    storage.add_user(user_entry)
-    print(f"[+] Пользователь {user['username']} добавлен.")
-
-def init_llm_backends(storage, config):
-    backends = config.get("llm_backends", [])
-    storage.clear_llm_registry()
-    for backend in backends:
-        backend_id = str(uuid.uuid4())
-        desc = f"{backend.get('type', 'unknown')} model"
-        llm = {
-            "id": backend_id,
-            "name": backend["name"],
-            "endpoint": desc,
-            "metadata": json.dumps(backend),
-            "created_at": datetime.now(UTC).isoformat()
-        }
-        storage.add_llm(llm)
-        print(f"[+] Зарегистрирован LLM: {backend['name']}")
-
-def init_config_table(storage, config):
-    exclude_keys = {"default_user", "llm_backends"}
-    flat_config = {k: v for k, v in config.items() if k not in exclude_keys}
-    for key, value in flat_config.items():
-        storage.set_config(key, json.dumps(value))
-    print("[+] Конфигурация сохранена в БД.")
-
-def init_prompts_and_ethics():
-    folder = os.path.dirname(__file__)
-    prompt_files = [
-        ("prompt.md", "full"),
-        ("prompt-short.md", "short")
-    ]
-    ethics_file = "ethics.yml"
-
-    with sqlite3.connect(DB_PATH) as conn:
-        cur = conn.cursor()
-
-        # Создаём таблицы при необходимости
-        cur.execute("""
-        CREATE TABLE IF NOT EXISTS system_prompts (
-            id TEXT PRIMARY KEY,
-            name TEXT NOT NULL,
-            type TEXT CHECK(type IN ('full','short')),
-            version TEXT,
-            source TEXT CHECK(source IN ('local','mesh','mixed')),
-            content TEXT NOT NULL,
-            updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-        )
-        """)
-        cur.execute("""
-        CREATE TABLE IF NOT EXISTS ethics_policies (
-            id TEXT PRIMARY KEY,
-            version TEXT,
-            source TEXT CHECK(source IN ('local','mesh','mixed')),
-            sync_enabled BOOLEAN,
-            mesh_endpoint TEXT,
-            consensus_threshold REAL,
-            check_interval TEXT,
-            model_type TEXT,
-            model_weights_json TEXT,
-            principles_json TEXT,
-            evaluation_json TEXT,
-            violation_policy_json TEXT,
-            audit_json TEXT,
-            updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-        )
-        """)
-
-        # Загружаем пром��ты
-        for fname, ptype in prompt_files:
-            fpath = os.path.join(folder, fname)
-            if not os.path.exists(fpath):
-                print(f"[-] Файл {fname} не найден, пропуск.")
-                continue
-            with open(fpath, "r", encoding="utf-8") as f:
-                content = f.read()
-            pid = hashlib.sha256(f"{fname}:{ptype}".encode()).hexdigest()
-            cur.execute("""
-                INSERT INTO system_prompts (id, name, type, version, source, content, updated_at)
-                VALUES (?, ?, ?, ?, ?, ?, ?)
-                ON CONFLICT(id) DO UPDATE SET
-                    content=excluded.content,
-                    updated_at=excluded.updated_at
-            """, (pid, fname, ptype, "1.0", "local", content, datetime.now(UTC).isoformat()))
-            print(f"[+] Загружен промпт: {fname} ({ptype})")
-
-        # Загружаем ethics.yml
-        efpath = os.path.join(folder, ethics_file)
-        if os.path.exists(efpath):
-            with open(efpath, "r", encoding="utf-8") as f:
-                ethics_data = yaml.safe_load(f)
-
-            eid = ethics_data.get("id", "default_ethics")
-            cur.execute("""
-                INSERT INTO ethics_policies (
-                    id, version, source,
-                    sync_enabled, mesh_endpoint, consensus_threshold, check_interval,
-                    model_type, model_weights_json, principles_json, evaluation_json,
-                    violation_policy_json, audit_json, updated_at
-                )
-                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-                ON CONFLICT(id) DO UPDATE SET
-                    version=excluded.version,
-                    source=excluded.source,
-                    sync_enabled=excluded.sync_enabled,
-                    mesh_endpoint=excluded.mesh_endpoint,
-                    consensus_threshold=excluded.consensus_threshold,
-                    check_interval=excluded.check_interval,
-                    model_type=excluded.model_type,
-                    model_weights_json=excluded.model_weights_json,
-                    principles_json=excluded.principles_json,
-                    evaluation_json=excluded.evaluation_json,
-                    violation_policy_json=excluded.violation_policy_json,
-                    audit_json=excluded.audit_json,
-                    updated_at=excluded.updated_at
-            """, (
-                eid,
-                ethics_data.get("version"),
-                ethics_data.get("source", "local"),
-                ethics_data.get("sync", {}).get("enabled", False),
-                ethics_data.get("sync", {}).get("mesh_endpoint"),
-                ethics_data.get("sync", {}).get("consensus_threshold"),
-                ethics_data.get("sync", {}).get("check_interval"),
-                ethics_data.get("model", {}).get("type"),
-                json.dumps(ethics_data.get("model", {}).get("weights"), ensure_ascii=False),
-                json.dumps(ethics_data.get("principles"), ensure_ascii=False),
-                json.dumps(ethics_data.get("evaluation"), ensure_ascii=False),
-                json.dumps(ethics_data.get("violation_policy"), ensure_ascii=False),
-                json.dumps(ethics_data.get("audit"), ensure_ascii=False),
-                datetime.now(UTC).isoformat()
-            ))
-            print(f"[+] Загружена этическая политика: {eid}")
-        else:
-            print(f"[-] Файл {ethics_file} не найден, пропуск.")
-
-def ensure_directories():
-    for folder in ["logs", "scripts"]:
-        full_path = os.path.abspath(os.path.join(os.path.dirname(__file__), folder))
-        if not os.path.exists(full_path):
-            os.makedirs(full_path)
-            print(f"[+] Создан каталог: {full_path}")
-        else:
-            print(f"[=] Каталог уже существует: {full_path}")
-
-def is_db_initialized(db_path):
-    if not os.path.exists(db_path):
-        return False
-    try:
-        with sqlite3.connect(db_path) as conn:
-            cursor = conn.cursor()
-            cursor.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='identity'")
-            return cursor.fetchone() is not None
-    except Exception:
-        return False
-
-def ensure_db_initialized():
-    config = load_config(CONFIG_PATH)
-
-    if not is_db_initialized(DB_PATH):
-        print("[*] БД не инициализирована — выполняем инициализацию.")
-        try:
-            ensure_directories()
-            storage = Storage()
-            init_identity(storage, config)
-            init_user(storage, config)
-            init_llm_backends(storage, config)
-            init_config_table(storage, config)
-            save_config(CONFIG_PATH, config)
-            init_prompts_and_ethics()
-        except Exception as e:
-            print(f"[!] Ошибка при инициализации: {e}")
-            sys.exit(1)
-    else:
-        print("[=] БД уже инициализирована.")
-
-    return config
-
-if __name__ == "__main__":
-    ensure_db_initialized()

agents/init.py

@@ -40,10 +40,15 @@ def expand_addresses(addresses):
 
 def init_identity(storage, config):
     if not config.get("agent_id"):
+        # 1. Сгенерировать DID
         did = generate_did()
-        pubkey, privkey = generate_keypair()
         identity_id = did.split(":")[-1]
 
+        # 2. Сгенерировать ключи через storage
+        privkey, pubkey = generate_keypair(method="ed25519")
+        privkey, pubkey = privkey.decode(), pubkey.decode()
+
+        # 3. Создать запись в identity
         identity = {
             "id": identity_id,
             "name": config.get("agent_name", "Unnamed"),
@@ -55,8 +60,12 @@ def init_identity(storage, config):
         }
         storage.add_identity(identity)
 
+        # 4. Записать в config
         config["agent_id"] = did
         config["identity_agent"] = identity_id
+        config["pubkey"] = pubkey
+        config["privkey"] = privkey
+
         save_config(CONFIG_PATH, config)
         print(f"[+] Создана личность: {identity_id}")
     else:

agents/tools/storage.py

@@ -677,6 +677,16 @@ class Storage:
         self.conn.commit()
         return cursor.lastrowid
 
+    def generate_pow(peer_id, pubkey, addresses, difficulty=4):
+        nonce = 0
+        prefix = "0" * difficulty
+        while True:
+            base = f"{peer_id}{pubkey}{''.join(addresses)}{nonce}".encode()
+            h = hashlib.sha256(base).hexdigest()
+            if h.startswith(prefix):
+                return nonce, h
+            nonce += 1
+
     # Управление основными процессами
     def update_heartbeat(self, name: str):
         now = datetime.now(UTC).isoformat()
@@ -884,7 +894,7 @@ class Storage:
             }
         return None
 
-    # Работа с пирам (agent_peers)
+    # Нормализация адресов
     @staticmethod
     def parse_hostport(s: str):
         """
@@ -936,7 +946,6 @@ class Storage:
                     return scope_id
         return None
 
-    # Нормализация адресов
     @classmethod
     def normalize_address(cls, addr: str) -> str:
         addr = addr.strip()
@@ -955,10 +964,17 @@ class Storage:
         return f"{proto}://{host}:{port}" if port else f"{proto}://{host}"
 
     # Работа с пирам (agent_peers)
+    def verify_pow(peer_id, pubkey, addresses, nonce, pow_hash, difficulty=4):
+        base = f"{peer_id}{pubkey}{''.join(addresses)}{nonce}".encode()
+        h = hashlib.sha256(base).hexdigest()
+        return h == pow_hash and h.startswith("0" * difficulty)
+
     def add_or_update_peer(
         self, peer_id, name, addresses,
         source="discovery", status="unknown",
-        pubkey=None, capabilities=None
+        pubkey=None, capabilities=None,
+        pow_nonce=None, pow_hash=None,
+        heard_from=None
     ):
         c = self.conn.cursor()
 
@@ -968,12 +984,13 @@ class Storage:
         existing_addresses = []
         existing_pubkey = None
         existing_capabilities = {}
+        existing_heard_from = []
 
         if peer_id:
-            c.execute("SELECT addresses, pubkey, capabilities FROM agent_peers WHERE id=?", (peer_id,))
+            c.execute("SELECT addresses, pubkey, capabilities, heard_from FROM agent_peers WHERE id=?", (peer_id,))
             row = c.fetchone()
             if row:
-                db_addresses_json, existing_pubkey, db_caps_json = row
+                db_addresses_json, existing_pubkey, db_caps_json, db_heard_from = row
                 try:
                     existing_addresses = json.loads(db_addresses_json) or []
                 except:
@@ -982,16 +999,32 @@ class Storage:
                     existing_capabilities = json.loads(db_caps_json) if db_caps_json else {}
                 except:
                     existing_capabilities = {}
+                try:
+                    existing_heard_from = json.loads(db_heard_from) if db_heard_from else []
+                except:
+                    existing_heard_from = []
 
-        # объединяем и нормализуем адреса, чтобы IPv6 всегда были с []
+        # объединяем адреса
         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  # не вставляем
+
         c.execute("""
-            INSERT INTO agent_peers (id, name, addresses, source, status, last_seen, pubkey, capabilities)
-            VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+            INSERT INTO agent_peers (id, name, addresses, source, status, last_seen, pubkey, capabilities, pow_nonce, pow_hash, heard_from)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
             ON CONFLICT(id) DO UPDATE SET
                 name=excluded.name,
                 addresses=excluded.addresses,
@@ -999,7 +1032,10 @@ class Storage:
                 status=excluded.status,
                 last_seen=excluded.last_seen,
                 pubkey=excluded.pubkey,
-                capabilities=excluded.capabilities
+                capabilities=excluded.capabilities,
+                pow_nonce=excluded.pow_nonce,
+                pow_hash=excluded.pow_hash,
+                heard_from=excluded.heard_from
         """, (
             peer_id,
             name,
@@ -1008,7 +1044,10 @@ class Storage:
             status,
             datetime.now(UTC).isoformat(),
             final_pubkey,
-            json.dumps(final_capabilities)
+            json.dumps(final_capabilities),
+            pow_nonce,
+            pow_hash,
+            json.dumps(combined_heard_from)
         ))
         self.conn.commit()