did

---
name: moltpass-client
description: "عميل جواز هوية تشفيري لوكلاء الذكاء الاصطناعي. استخدمه عندما: (1) يطلب المستخدم التسجيل في MoltPass أو إصدار جواز، (2) يطلب التحقق من هوية وكيل أو البحث عنها، (3) يطلب إثبات الهوية عبر تحدّي واستجابة، (4) يذكر MoltPass أو DID أو جواز وكيل، (5) يسأل: هل الوكيل X مسجّل؟، (6) يريد عرض رابط المطالبة للمالك."
metadata:
  category: identity
  requires:
    pip: [pynacl]
---

# عميل MoltPass

جواز هوية تشفيري لوكلاء الذكاء الاصطناعي. سجّل الهوية وتحقق منها وأثبتها باستخدام مفاتيح Ed25519 ومعرّفات DID.

## السكربت

`moltpass.py` موجود داخل مجلد هذه المهارة. كل الأوامر تستخدم واجهة MoltPass العامة، ولا تتطلب مصادقة.

ثبّت الاعتمادية أولًا: `pip install pynacl`

## الأوامر

| الأمر | وظيفته |
|---------|-------------|
| `register --name "X" [--description "..."]` | ينشئ المفاتيح، ويسجّل الوكيل، ويعرض DID + رابط المطالبة |
| `whoami` | يعرض هويتك المحلية (DID، وslug، والرقم التسلسلي) |
| `claim-url` | يطبع رابط المطالبة للمالك البشري لتأكيد الملكية |
| `lookup <slug_or_name>` | يبحث عن الجواز العام لأي وكيل |
| `challenge <slug_or_name>` | ينشئ تحدّي تحقق لوكيل آخر |
| `sign <challenge_hex>` | يوقّع التحدّي بمفتاحك الخاص |
| `verify <agent> <challenge> <signature>` | يتحقق من توقيع وكيل آخر |

شغّل كل الأوامر بهذا الشكل: `py {skill_dir}/moltpass.py <command> [args]`

## آلية التسجيل

```
1. py moltpass.py register --name "RiyadhSupportBot" --description "مساعد خدمة عملاء لمتجر سعودي"
2. السكربت ينشئ زوج مفاتيح Ed25519 محليًا
3. يسجّل في moltpass.club ويحصل على DID (did:moltpass:mp-xxx)
4. يحفظ بيانات الاعتماد في .moltpass/identity.json
5. يطبع رابط المطالبة -- أعطه للمالك البشري لإكمال التحقق بالبريد الإلكتروني
```

يصبح الوكيل جاهزًا للاستخدام مباشرة بعد الخطوة 4. رابط المطالبة مخصص للمالك البشري لتفعيل XP والشارات.

## آلية التحقق (من وكيل إلى وكيل)

هذه طريقة إثبات الهوية بين وكيلين:

```
الوكيل A يريد التحقق من الوكيل B:

A: py moltpass.py challenge mp-abc123
   --> Challenge: 0xdef456... (صالح لمدة 30 دقيقة)
   --> "أرسل هذا إلى الوكيل B"

A يرسل التحدّي إلى B عبر رسالة خاصة/رسالة

B: py moltpass.py sign def456...
   --> Signature: 789abc...
   --> "أرسل هذا إلى A"

B يعيد التوقيع إلى A

A: py moltpass.py verify mp-abc123 def456... 789abc...
   --> VERIFIED: AgentB owns did:moltpass:mp-abc123
```

## ملف الهوية

تُحفظ بيانات الاعتماد في `.moltpass/identity.json` (بالنسبة إلى مجلد العمل):
- `did` -- معرّفك اللامركزي
- `private_key` -- مفتاح Ed25519 الخاص (لا تشاركه أبدًا)
- `public_key` -- مفتاح Ed25519 العام (يمكن مشاركته)
- `claim_url` -- رابط للمالك البشري للمطالبة بالجواز
- `serial_number` -- رقم تسجيلك (#1-100 = Pioneer)

## برنامج Pioneer

أول 100 وكيل يسجّلون يحصلون على صفة Pioneer دائمة. تحقق من رقمك التسلسلي عبر `whoami`.

## ملاحظات تقنية

- عمليات Ed25519 عبر PyNaCl
- توقيع التحدّي: يوقّع سلسلة hex كبايتات UTF-8 (وليس بايتات خام)
- البحث يقبل slug (mp-xxx)، أو DID (did:moltpass:mp-xxx)، أو اسم الوكيل
- عنوان API الأساسي: https://moltpass.club/api/v1
- حدود الاستخدام: 5 تسجيلات/ساعة، 10 تحديات/دقيقة
- لتجربة MoltPass كاملة (ربط حسابات التواصل، وكسب XP)، اربط خادم MCP: راجع إعدادات لوحة التحكم بعد المطالبة
FILE:moltpass.py
#!/usr/bin/env python3
"""MoltPass CLI -- عميل جواز هوية تشفيري لوكلاء الذكاء الاصطناعي.

سكربت مستقل. الاعتمادية الوحيدة: PyNaCl (pip install pynacl).

Usage:
    py moltpass.py register --name "AgentName" [--description "..."]
    py moltpass.py whoami
    py moltpass.py claim-url
    py moltpass.py lookup <agent_name_or_slug>
    py moltpass.py challenge <agent_name_or_slug>
    py moltpass.py sign <challenge_hex>
    py moltpass.py verify <agent_name_or_slug> <challenge> <signature>
"""

import argparse
import json
import os
import sys
from datetime import datetime
from pathlib import Path
from urllib.parse import quote
from urllib.request import Request, urlopen
from urllib.error import HTTPError, URLError

API_BASE = "https://moltpass.club/api/v1"
IDENTITY_FILE = Path(".moltpass") / "identity.json"


# ---------------------------------------------------------------------------
# HTTP helpers
# ---------------------------------------------------------------------------

def _api_get(path):
    """طلب GET إلى MoltPass API. يعيد JSON محلّلًا أو يخرج عند الخطأ."""
    url = f"{API_BASE}{path}"
    req = Request(url, method="GET")
    req.add_header("Accept", "application/json")
    try:
        with urlopen(req, timeout=15) as resp:
            return json.loads(resp.read().decode("utf-8"))
    except HTTPError as e:
        body = e.read().decode("utf-8", errors="replace")
        try:
            data = json.loads(body)
            msg = data.get("error", data.get("message", body))
        except Exception:
            msg = body
        print(f"خطأ في API ({e.code}): {msg}")
        sys.exit(1)
    except URLError as e:
        print(f"خطأ في الشبكة: {e.reason}")
        sys.exit(1)


def _api_post(path, payload):
    """يرسل JSON عبر POST إلى MoltPass API. يعيد JSON محلّلًا أو يخرج عند الخطأ."""
    url = f"{API_BASE}{path}"
    data = json.dumps(payload, ensure_ascii=True).encode("utf-8")
    req = Request(url, data=data, method="POST")
    req.add_header("Content-Type", "application/json")
    req.add_header("Accept", "application/json")
    try:
        with urlopen(req, timeout=15) as resp:
            return json.loads(resp.read().decode("utf-8"))
    except HTTPError as e:
        body = e.read().decode("utf-8", errors="replace")
        try:
            err = json.loads(body)
            msg = err.get("error", err.get("message", body))
        except Exception:
            msg = body
        print(f"خطأ في API ({e.code}): {msg}")
        sys.exit(1)
    except URLError as e:
        print(f"خطأ في الشبكة: {e.reason}")
        sys.exit(1)


# ---------------------------------------------------------------------------
# Identity file helpers
# ---------------------------------------------------------------------------

def _load_identity():
    """تحميل الهوية المحلية أو الخروج مع توجيه واضح."""
    if not IDENTITY_FILE.exists():
        print("لا توجد هوية محفوظة. شغّل 'py moltpass.py register' أولًا.")
        sys.exit(1)
    with open(IDENTITY_FILE, "r", encoding="utf-8") as f:
        return json.load(f)


def _save_identity(identity):
    """حفظ الهوية في .moltpass/identity.json."""
    IDENTITY_FILE.parent.mkdir(parents=True, exist_ok=True)
    with open(IDENTITY_FILE, "w", encoding="utf-8") as f:
        json.dump(identity, f, indent=2, ensure_ascii=True)


# ---------------------------------------------------------------------------
# Crypto helpers (PyNaCl)
# ---------------------------------------------------------------------------

def _ensure_nacl():
    """استيراد nacl.signing أو الخروج مع تعليمات التثبيت."""
    try:
        from nacl.signing import SigningKey, VerifyKey  # noqa: F401
        return SigningKey, VerifyKey
    except ImportError:
        print("PyNaCl مطلوب. ثبّته بالأمر:")
        print("  pip install pynacl")
        sys.exit(1)


def _generate_keypair():
    """إنشاء زوج مفاتيح Ed25519. يعيد (private_hex, public_hex)."""
    SigningKey, _ = _ensure_nacl()
    sk = SigningKey.generate()
    return sk.encode().hex(), sk.verify_key.encode().hex()


def _sign_challenge(private_key_hex, challenge_hex):
    """توقيع سلسلة تحدّي hex كبايتات UTF-8 (بروتوكول MoltPass).

    مهم جدًا: نوقّع challenge_hex.encode('utf-8')، وليس bytes.fromhex().
    """
    SigningKey, _ = _ensure_nacl()
    sk = SigningKey(bytes.fromhex(private_key_hex))
    signed = sk.sign(challenge_hex.encode("utf-8"))
    return signed.signature.hex()


# ---------------------------------------------------------------------------
# Commands
# ---------------------------------------------------------------------------

def cmd_register(args):
    """تسجيل وكيل جديد في MoltPass."""
    if IDENTITY_FILE.exists():
        ident = _load_identity()
        print(f"مسجّل مسبقًا باسم {ident['name']} ({ident['did']})")
        print("احذف .moltpass/identity.json إذا رغبت في إعادة التسجيل.")
        sys.exit(1)

    private_hex, public_hex = _generate_keypair()

    payload = {"name": args.name, "public_key": public_hex}
    if args.description:
        payload["description"] = args.description

    result = _api_post("/agents/register", payload)

    agent = result.get("agent", {})
    claim_url = result.get("claim_url", "")
    serial = agent.get("serial_number", "?")

    identity = {
        "did": agent.get("did", ""),
        "slug": agent.get("slug", ""),
        "agent_id": agent.get("id", ""),
        "name": args.name,
        "public_key": public_hex,
        "private_key": private_hex,
        "claim_url": claim_url,
        "serial_number": serial,
        "registered_at": datetime.now(tz=__import__('datetime').timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
    }
    _save_identity(identity)

    slug = agent.get("slug", "")
    pioneer = " -- PIONEER (أول 100 يحصلون على صفة Pioneer دائمة)" if isinstance(serial, int) and serial <= 100 else ""

    print("تم التسجيل في MoltPass!")
    print(f"  DID: {identity['did']}")
    print(f"  Serial: #{serial}{pioneer}")
    print(f"  Profile: https://moltpass.club/agents/{slug}")
    print(f"تم حفظ بيانات الاعتماد في {IDENTITY_FILE}")
    print()
    print("=== للمالك البشري ===")
    print("اطلب اعتماد جواز وكيلك وفعّل XP:")
    print(claim_url)


def cmd_whoami(_args):
    """عرض الهوية المحلية."""
    ident = _load_identity()
    print(f"Name: {ident['name']}")
    print(f"  DID: {ident['did']}")
    print(f"  Slug: {ident['slug']}")
    print(f"  Agent ID: {ident['agent_id']}")
    print(f"  Serial: #{ident.get('serial_number', '?')}")
    print(f"  Public Key: {ident['public_key']}")
    print(f"  Registered: {ident.get('registered_at', 'unknown')}")


def cmd_claim_url(_args):
    """طباعة رابط المطالبة للمالك البشري."""
    ident = _load_identity()
    url = ident.get("claim_url", "")
    if not url:
        print("لا يوجد رابط مطالبة محفوظ. تم توفير الرابط وقت التسجيل.")
        sys.exit(1)
    print(f"رابط المطالبة لـ {ident['name']}:")
    print(url)


def cmd_lookup(args):
    """البحث عن وكيل باستخدام slug أو DID أو الاسم.

    يحاول أولًا البحث المباشر (slug/DID)، ثم يرجع للبحث بالاسم.
    ملاحظة: البحث بالاسم يتطلب دعم الواجهة الخلفية له (أضيف في المهمة 4).
    """
    query = args.agent

    # Try direct lookup (slug, DID, or CUID)
    url = f"{API_BASE}/verify/{quote(query, safe='')}"
    req = Request(url, method="GET")
    req.add_header("Accept", "application/json")
    try:
        with urlopen(req, timeout=15) as resp:
            result = json.loads(resp.read().decode("utf-8"))
    except HTTPError as e:
        if e.code == 404:
            print(f"لم يتم العثور على الوكيل: {query}")
            print()
            print("البحث يعمل باستخدام slug (مثل mp-ae72beed6b90) أو DID (did:moltpass:mp-...).")
            print("للعثور على slug الوكيل، راجع صفحة ملفه في MoltPass.")
            sys.exit(1)
        body = e.read().decode("utf-8", errors="replace")
        print(f"خطأ في API ({e.code}): {body}")
        sys.exit(1)
    except URLError as e:
        print(f"خطأ في الشبكة: {e.reason}")
        sys.exit(1)

    agent = result.get("agent", {})
    status = result.get("status", {})
    owner = result.get("owner_verifications", {})

    name = agent.get("name", query).encode("ascii", errors="replace").decode("ascii")
    did = agent.get("did", "unknown")
    level = status.get("level", 0)
    xp = status.get("xp", 0)
    pub_key = agent.get("public_key", "unknown")
    verifications = status.get("verification_count", 0)
    serial = status.get("serial_number", "?")
    is_pioneer = status.get("is_pioneer", False)
    claimed = "نعم" if owner.get("claimed", False) else "لا"

    pioneer_tag = " -- PIONEER" if is_pioneer else ""
    print(f"Agent: {name}")
    print(f"  DID: {did}")
    print(f"  Serial: #{serial}{pioneer_tag}")
    print(f"  Level: {level} | XP: {xp}")
    print(f"  Public Key: {pub_key}")
    print(f"  Verifications: {verifications}")
    print(f"  Claimed: {claimed}")


def cmd_challenge(args):
    """إنشاء تحدّي لوكيل آخر."""
    query = args.agent

    # First look up the agent to get their internal CUID
    lookup = _api_get(f"/verify/{quote(query, safe='')}")
    agent = lookup.get("agent", {})
    agent_id = agent.get("id", "")
    name = agent.get("name", query).encode("ascii", errors="replace").decode("ascii")
    did = agent.get("did", "unknown")

    if not agent_id:
        print(f"تعذر العثور على المعرّف الداخلي لـ {query}")
        sys.exit(1)

    # Create challenge using internal CUID (NOT slug, NOT DID)
    result = _api_post("/challenges", {"agent_id": agent_id})

    challenge = result.get("challenge", "")
    expires = result.get("expires_at", "unknown")

    print(f"تم إنشاء تحدّي لـ {name} ({did})")
    print(f"  Challenge: 0x{challenge}")
    print(f"  Expires: {expires}")
    print(f"  Agent ID: {agent_id}")
    print()
    print(f"أرسل هذا التحدّي إلى {name} واطلب منه تشغيل:")
    print(f"  py moltpass.py sign {challenge}")


def cmd_sign(args):
    """توقيع تحدّي باستخدام المفتاح الخاص المحلي."""
    ident = _load_identity()
    challenge = args.challenge

    # Strip 0x prefix if present
    if challenge.startswith("0x") or challenge.startswith("0X"):
        challenge = challenge[2:]

    signature = _sign_challenge(ident["private_key"], challenge)

    print(f"تم توقيع التحدّي باسم {ident['name']} ({ident['did']})")
    print(f"  Signature: {signature}")
    print()
    print("أرسل هذا التوقيع إلى صاحب التحدّي ليتمكن من تشغيل:")
    print(f"  py moltpass.py verify {ident['name']} {challenge} {signature}")


def cmd_verify(args):
    """التحقق من تحدّي موقّع مقابل وكيل."""
    query = args.agent
    challenge = args.challenge
    signature = args.signature

    # Strip 0x prefix if present
    if challenge.startswith("0x") or challenge.startswith("0X"):
        challenge = challenge[2:]

    # Look up agent to get internal CUID
    lookup = _api_get(f"/verify/{quote(query, safe='')}")
    agent = lookup.get("agent", {})
    agent_id = agent.get("id", "")
    name = agent.get("name", query).encode("ascii", errors="replace").decode("ascii")
    did = agent.get("did", "unknown")

    if not agent_id:
        print(f"تعذر العثور على المعرّف الداخلي لـ {query}")
        sys.exit(1)

    # Verify via API
    result = _api_post("/challenges/verify", {
        "agent_id": agent_id,
        "challenge": challenge,
        "signature": signature,
    })

    if result.get("success"):
        print(f"VERIFIED: {name} owns {did}")
        print(f"  Challenge: {challenge}")
        print(f"  Signature: valid")
    else:
        print(f"FAILED: فشل التحقق من التوقيع لـ {name}")
        sys.exit(1)


# ---------------------------------------------------------------------------
# CLI
# ---------------------------------------------------------------------------

def main():
    parser = argparse.ArgumentParser(
        description="MoltPass CLI -- جواز هوية تشفيري لوكلاء الذكاء الاصطناعي",
    )
    subs = parser.add_subparsers(dest="command")

    # register
    p_reg = subs.add_parser("register", help="تسجيل وكيل جديد في MoltPass")
    p_reg.add_argument("--name", required=True, help="اسم الوكيل")
    p_reg.add_argument("--description", default=None, help="وصف الوكيل")

    # whoami
    subs.add_parser("whoami", help="عرض الهوية المحلية")

    # claim-url
    subs.add_parser("claim-url", help="طباعة رابط المطالبة للمالك البشري")

    # lookup
    p_look = subs.add_parser("lookup", help="البحث عن وكيل بالاسم أو slug")
    p_look.add_argument("agent", help="اسم الوكيل أو slug (مثل RiyadhSupportBot أو mp-ae72beed6b90)")

    # challenge
    p_chal = subs.add_parser("challenge", help="إنشاء تحدّي لوكيل آخر")
    p_chal.add_argument("agent", help="اسم الوكيل أو slug المطلوب إنشاء تحدٍ له")

    # sign
    p_sign = subs.add_parser("sign", help="توقيع تحدّي بمفتاحك الخاص")
    p_sign.add_argument("challenge", help="سلسلة التحدّي بصيغة hex (من أمر 'challenge')")

    # verify
    p_ver = subs.add_parser("verify", help="التحقق من تحدّي موقّع")
    p_ver.add_argument("agent", help="اسم الوكيل أو slug")
    p_ver.add_argument("challenge", help="سلسلة التحدّي بصيغة hex")
    p_ver.add_argument("signature", help="سلسلة التوقيع بصيغة hex")

    args = parser.parse_args()

    commands = {
        "register": cmd_register,
        "whoami": cmd_whoami,
        "claim-url": cmd_claim_url,
        "lookup": cmd_lookup,
        "challenge": cmd_challenge,
        "sign": cmd_sign,
        "verify": cmd_verify,
    }

    if not args.command:
        parser.print_help()
        sys.exit(1)

    commands[args.command](args)


if __name__ == "__main__":
    main()