x-nava 1.0.0__tar.gz

x_nava-1.0.0/PKG-INFO

@@ -0,0 +1,58 @@
+Metadata-Version: 2.4
+Name: x-nava
+Version: 1.0.0
+Summary: Python-native messaging client with an embedded runtime
+Author: x_nava contributors
+License: MIT
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# x_nava for Python — Termux
+
+مكتبة Python للتعامل مع WhatsApp عبر Baileys. هذه النسخة مناسبة لـ **Termux على Android**: لا تستخدم Node.js المضمّن الخاص بسطح المكتب، بل تعتمد على Node.js الذي يثبّته Termux.
+
+> غير تابعة لـ WhatsApp أو Meta. استخدمها وفق القوانين وشروط الخدمة، ولا تستخدمها للسبام.
+
+## التثبيت على Termux
+
+```bash
+pkg update -y
+pkg install -y python nodejs-lts unzip
+unzip x_nava-1.0.0-termux.zip
+cd x_nava-1.0.0-termux
+python -m pip install --upgrade pip
+python -m pip install .
+```
+
+في أول تشغيل ستثبت المكتبة تلقائياً اعتماد Baileys داخل `~/.x_nava_runtime`. للتثبيت اليدوي:
+
+```bash
+cd ~/.x_nava_runtime
+npm install --no-audit --no-fund --save-exact
+```
+
+## مثال سريع
+
+```python
+import asyncio
+from x_nava import MoXstarClient
+
+async def main():
+    client = MoXstarClient(auth_dir='./auth')
+    client.on('qr', lambda code: print('QR:', code))
+    client.on('ready', lambda _: print('x_nava جاهزة'))
+    await client.start()
+    await client.wait_until_ready()
+    await client.wait_closed()
+
+asyncio.run(main())
+```
+
+يمكن تحديد مسار Node يدوياً عبر متغير البيئة `NAVAPRO_NODE`، لكن الوضع الافتراضي يستخدم `node` الموجود في Termux.
+
+## ملاحظات Android/Termux
+
+- استخدم `nodejs-lts` وليس نسخة Node مكتبية مضمّنة.
+- يفضّل تعطيل تحسين البطارية لتطبيق Termux حتى لا ينقطع الاتصال في الخلفية.
+- الاتصال الحي يحتاج QR أو Pairing Code ورقم WhatsApp حقيقي.
+- اختبارات Python المحلية لا تتصل بواتساب.

x_nava-1.0.0/README.md

@@ -0,0 +1,49 @@
+# x_nava for Python — Termux
+
+مكتبة Python للتعامل مع WhatsApp عبر Baileys. هذه النسخة مناسبة لـ **Termux على Android**: لا تستخدم Node.js المضمّن الخاص بسطح المكتب، بل تعتمد على Node.js الذي يثبّته Termux.
+
+> غير تابعة لـ WhatsApp أو Meta. استخدمها وفق القوانين وشروط الخدمة، ولا تستخدمها للسبام.
+
+## التثبيت على Termux
+
+```bash
+pkg update -y
+pkg install -y python nodejs-lts unzip
+unzip x_nava-1.0.0-termux.zip
+cd x_nava-1.0.0-termux
+python -m pip install --upgrade pip
+python -m pip install .
+```
+
+في أول تشغيل ستثبت المكتبة تلقائياً اعتماد Baileys داخل `~/.x_nava_runtime`. للتثبيت اليدوي:
+
+```bash
+cd ~/.x_nava_runtime
+npm install --no-audit --no-fund --save-exact
+```
+
+## مثال سريع
+
+```python
+import asyncio
+from x_nava import MoXstarClient
+
+async def main():
+    client = MoXstarClient(auth_dir='./auth')
+    client.on('qr', lambda code: print('QR:', code))
+    client.on('ready', lambda _: print('x_nava جاهزة'))
+    await client.start()
+    await client.wait_until_ready()
+    await client.wait_closed()
+
+asyncio.run(main())
+```
+
+يمكن تحديد مسار Node يدوياً عبر متغير البيئة `NAVAPRO_NODE`، لكن الوضع الافتراضي يستخدم `node` الموجود في Termux.
+
+## ملاحظات Android/Termux
+
+- استخدم `nodejs-lts` وليس نسخة Node مكتبية مضمّنة.
+- يفضّل تعطيل تحسين البطارية لتطبيق Termux حتى لا ينقطع الاتصال في الخلفية.
+- الاتصال الحي يحتاج QR أو Pairing Code ورقم WhatsApp حقيقي.
+- اختبارات Python المحلية لا تتصل بواتساب.

x_nava-1.0.0/pyproject.toml

@@ -0,0 +1,22 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "x-nava"
+version = "1.0.0"
+description = "Python-native messaging client with an embedded runtime"
+requires-python = ">=3.9"
+readme = "README.md"
+license = {text = "MIT"}
+authors = [{name = "x_nava contributors"}]
+dependencies = []
+
+[tool.setuptools]
+packages = ["x_nava"]
+
+[tool.setuptools.package-data]
+x_nava = ["engine.js", "package.json", "runtime/node", "runtime/node.exe", "runtime/engine.js", "runtime/package.json", "runtime/node_modules/**/*"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

x_nava-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

x_nava-1.0.0/tests/test_client.py

@@ -0,0 +1,19 @@
+import asyncio
+from x_nava.client import Message, EventBus
+
+
+def test_message_model():
+    m = Message.from_dict({'id': 'x', 'chat_id': '1@s.whatsapp.net', 'text': 'hello'})
+    assert m.id == 'x'
+    assert m.text == 'hello'
+    assert m.chat_id == '1@s.whatsapp.net'
+
+
+def test_event_bus_supports_async_handlers():
+    async def run():
+        bus = EventBus()
+        seen = []
+        bus.on('message', lambda value: seen.append(value))
+        await bus.emit('message', 'ok')
+        assert seen == ['ok']
+    asyncio.run(run())

x_nava-1.0.0/x_nava/__init__.py

@@ -0,0 +1,4 @@
+from .client import MoXstarClient, Message, ConnectionState, BridgeError, BridgeOffline, BridgeTimeout
+
+__all__ = ["MoXstarClient", "Message", "ConnectionState", "BridgeError", "BridgeOffline", "BridgeTimeout"]
+__version__ = "1.0.0"

x_nava-1.0.0/x_nava/client.py

@@ -0,0 +1,333 @@
+from __future__ import annotations
+
+import asyncio
+import json
+import os
+import shutil
+import subprocess
+import sys
+import time
+import platform
+from dataclasses import dataclass
+from enum import Enum
+from pathlib import Path
+from typing import Any, Awaitable, Callable
+
+Handler = Callable[[Any], Any]
+
+
+class BridgeError(RuntimeError):
+    pass
+
+
+class BridgeOffline(BridgeError):
+    pass
+
+
+class BridgeTimeout(BridgeError):
+    pass
+
+
+class ConnectionState(str, Enum):
+    DISCONNECTED = "disconnected"
+    STARTING = "starting"
+    CONNECTED = "connected"
+    CLOSED = "closed"
+
+
+@dataclass(slots=True)
+class Message:
+    id: str
+    chat_id: str
+    sender_id: str | None = None
+    from_me: bool = False
+    is_group: bool = False
+    text: str | None = None
+    type: str = "unknown"
+    timestamp: int | None = None
+    push_name: str | None = None
+    raw: dict[str, Any] | None = None
+
+    @classmethod
+    def from_dict(cls, value: dict[str, Any]) -> "Message":
+        return cls(id=value.get("id", ""), chat_id=value.get("chat_id", ""), sender_id=value.get("sender_id"), from_me=bool(value.get("from_me")), is_group=bool(value.get("is_group")), text=value.get("text"), type=value.get("type", "unknown"), timestamp=value.get("timestamp"), push_name=value.get("push_name"), raw=value.get("raw"))
+
+
+class EventBus:
+    def __init__(self) -> None:
+        self._handlers: dict[str, list[Handler]] = {}
+
+    def on(self, event: str, handler: Handler) -> Handler:
+        self._handlers.setdefault(event, []).append(handler)
+        return handler
+
+    def off(self, event: str, handler: Handler) -> None:
+        if event in self._handlers and handler in self._handlers[event]:
+            self._handlers[event].remove(handler)
+
+    async def emit(self, event: str, value: Any) -> None:
+        for handler in tuple(self._handlers.get(event, ())):
+            result = handler(value)
+            if inspect_awaitable(result):
+                await result
+
+
+def inspect_awaitable(value: Any) -> bool:
+    return hasattr(value, "__await__")
+
+
+class MoXstarClient:
+    """Python-native x_nava client backed by an embedded messaging process."""
+
+    def __init__(self, auth_dir: str = "./auth", runtime_dir: str | None = None, auto_install: bool = True, node_path: str | None = None) -> None:
+        self.auth_dir = Path(auth_dir).expanduser().resolve()
+        self.runtime_dir = Path(runtime_dir or (Path.home() / ".x_nava_runtime")).expanduser().resolve()
+        self.auto_install = auto_install
+        self.node_path = node_path
+        self.process: asyncio.subprocess.Process | None = None
+        self.events = EventBus()
+        self._pending: dict[str, asyncio.Future[dict[str, Any]]] = {}
+        self._counter = 0
+        self._reader_task: asyncio.Task[None] | None = None
+        self._stderr_task: asyncio.Task[None] | None = None
+        self._waiter: asyncio.Future[None] | None = None
+        self._ready = False
+        self.auth_dir.mkdir(parents=True, exist_ok=True)
+
+    @staticmethod
+    def _is_termux() -> bool:
+        # Termux reports Linux but exposes these environment markers.
+        return bool(
+            os.environ.get("TERMUX_VERSION")
+            or os.environ.get("PREFIX", "").startswith("/data/data/com.termux")
+        )
+
+    def on(self, event: str, handler: Handler) -> Handler:
+        return self.events.on(event, handler)
+
+    def off(self, event: str, handler: Handler) -> None:
+        self.events.off(event, handler)
+
+    @property
+    def connected(self) -> bool:
+        return self._ready and self.process is not None and self.process.returncode is None
+
+    @property
+    def alive(self) -> bool:
+        return self.process is not None and self.process.returncode is None
+
+    def _ensure_runtime(self) -> Path:
+        source_dir = Path(__file__).resolve().parent
+        bundled_dir = source_dir / "runtime"
+        bundled_node = bundled_dir / ("node.exe" if sys.platform == "win32" else "node")
+        bundled_engine = bundled_dir / "engine.js"
+        bundled_baileys = bundled_dir / "node_modules" / "@whiskeysockets" / "baileys" / "package.json"
+        # Android/Termux cannot execute the desktop Node binary shipped in
+        # desktop wheels. Always use Termux's nodejs-lts there.
+        if not self._is_termux() and not self.node_path and bundled_node.exists() and bundled_engine.exists() and bundled_baileys.exists():
+            return bundled_engine
+        node = self.node_path or os.environ.get("NAVAPRO_NODE") or shutil.which("node")
+        npm = os.environ.get("NAVAPRO_NPM") or shutil.which("npm")
+        if not node:
+            raise BridgeError("No Node.js runtime found. In Termux run: pkg update && pkg install nodejs-lts")
+        if not npm:
+            raise BridgeError("No npm found. In Termux install nodejs-lts (it provides npm).")
+        self.runtime_dir.mkdir(parents=True, exist_ok=True)
+        package = self.runtime_dir / "package.json"
+        engine = self.runtime_dir / "engine.js"
+        package.write_text((source_dir / "package.json").read_text(encoding="utf-8"), encoding="utf-8")
+        engine.write_text((source_dir / "engine.js").read_text(encoding="utf-8"), encoding="utf-8")
+        installed = self.runtime_dir / "node_modules" / "@whiskeysockets" / "baileys" / "package.json"
+        if not installed.exists():
+            if not self.auto_install:
+                raise BridgeError("Baileys is not installed. Use auto_install=True or run npm install in the runtime directory.")
+            subprocess.run([npm, "install", "--no-audit", "--no-fund", "--save-exact"], cwd=self.runtime_dir, check=True)
+        return engine
+
+    def _node_executable(self) -> str | None:
+        """Return the bundled node binary when present, otherwise a system Node."""
+        bundled = Path(__file__).resolve().parent / "runtime" / ("node.exe" if sys.platform == "win32" else "node")
+        if not self._is_termux() and bundled.exists():
+            return str(bundled)
+        return self.node_path or os.environ.get("NAVAPRO_NODE") or shutil.which("node")
+
+    async def start(self) -> None:
+        if self.alive:
+            return
+        engine = self._ensure_runtime()
+        node = self._node_executable()
+        if not node:
+            raise BridgeError("x_nava could not locate its bundled or system Node runtime.")
+        env = os.environ.copy()
+        env["x_nava_AUTH_DIR"] = str(self.auth_dir)
+        self.process = await asyncio.create_subprocess_exec(node, str(engine), cwd=str(engine.parent), env=env, stdin=asyncio.subprocess.PIPE, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE)
+        self._waiter = asyncio.get_running_loop().create_future()
+        self._reader_task = asyncio.create_task(self._read_stdout())
+        self._stderr_task = asyncio.create_task(self._read_stderr())
+        await self._request("start")
+
+    async def _read_stdout(self) -> None:
+        assert self.process and self.process.stdout
+        async for raw in self.process.stdout:
+            try:
+                packet = json.loads(raw.decode("utf-8"))
+            except (UnicodeDecodeError, json.JSONDecodeError):
+                continue
+            request_id = packet.get("request_id")
+            if request_id and request_id in self._pending:
+                future = self._pending.pop(request_id)
+                if not future.done():
+                    future.set_result(packet)
+                continue
+            event = packet.get("event")
+            data = packet.get("data")
+            if event == "ready":
+                self._ready = True
+                if self._waiter and not self._waiter.done(): self._waiter.set_result(None)
+            elif event == "close":
+                self._ready = False
+            elif event == "error":
+                await self.events.emit("error", BridgeError(data.get("message", "Engine error")))
+            if event:
+                if event == "messages.upsert" and isinstance(data, dict):
+                    data = {**data, "messages": [Message.from_dict(x) for x in data.get("messages", [])]}
+                await self.events.emit(event, data)
+
+    async def _read_stderr(self) -> None:
+        if not self.process or not self.process.stderr:
+            return
+        async for raw in self.process.stderr:
+            await self.events.emit("log", raw.decode("utf-8", errors="replace").rstrip())
+
+    async def _request(self, action: str, timeout: float = 30.0, **payload: Any) -> dict[str, Any]:
+        if not self.process or not self.process.stdin or self.process.returncode is not None:
+            raise BridgeOffline("x_nava engine is not running")
+        self._counter += 1
+        request_id = str(self._counter)
+        future: asyncio.Future[dict[str, Any]] = asyncio.get_running_loop().create_future()
+        self._pending[request_id] = future
+        command = {"action": action, "request_id": request_id, **payload}
+        try:
+            self.process.stdin.write((json.dumps(command, ensure_ascii=False) + "\n").encode())
+            await self.process.stdin.drain()
+            packet = await asyncio.wait_for(future, timeout)
+        except asyncio.TimeoutError as exc:
+            self._pending.pop(request_id, None)
+            raise BridgeTimeout(f"Timed out waiting for {action}") from exc
+        if not packet.get("ok"):
+            raise BridgeError(packet.get("error", {}).get("message", "Engine request failed"))
+        return packet.get("result", {})
+
+    async def wait_until_ready(self, timeout: float | None = None) -> None:
+        if self.connected:
+            return
+        if self._waiter is None:
+            raise BridgeOffline("Call start() first")
+        await asyncio.wait_for(asyncio.shield(self._waiter), timeout) if timeout else await self._waiter
+
+    async def wait_closed(self) -> None:
+        if self.process:
+            await self.process.wait()
+
+    async def request_pairing_code(self, phone: str) -> str:
+        return str((await self._request("pairing_code", phone=phone))["code"])
+
+    async def send_message(self, to: str, content: dict[str, Any]) -> dict[str, Any]:
+        return await self._request("send_message", to=to, content=content)
+
+    async def send_text(self, to: str, text: str) -> dict[str, Any]:
+        if not isinstance(text, str) or not 1 <= len(text) <= 4096:
+            raise ValueError("text must be between 1 and 4096 characters")
+        return await self.send_message(to, {"text": text})
+
+    async def send_image(self, to: str, image: str | bytes, caption: str | None = None) -> dict[str, Any]:
+        return await self.send_message(to, {"image": image.decode() if isinstance(image, bytes) else image, "caption": caption})
+
+    async def send_video(self, to: str, video: str | bytes, caption: str | None = None) -> dict[str, Any]:
+        return await self.send_message(to, {"video": video.decode() if isinstance(video, bytes) else video, "caption": caption})
+
+    async def send_document(self, to: str, document: str | bytes, file_name: str, mimetype: str = "application/octet-stream") -> dict[str, Any]:
+        return await self.send_message(to, {"document": document.decode() if isinstance(document, bytes) else document, "fileName": file_name, "mimetype": mimetype})
+
+    async def send_audio(self, to: str, audio: str | bytes, mimetype: str = "audio/mp4") -> dict[str, Any]:
+        return await self.send_message(to, {"audio": audio.decode() if isinstance(audio, bytes) else audio, "mimetype": mimetype})
+
+    async def send_location(self, to: str, latitude: float, longitude: float, name: str | None = None) -> dict[str, Any]:
+        return await self.send_message(to, {"location": {"degreesLatitude": latitude, "degreesLongitude": longitude, "name": name}})
+
+    async def raw_request(self, method: str, *args: Any) -> Any:
+        """Call a supported Baileys socket method for advanced use cases."""
+        return (await self._request("baileys_call", method=method, args=list(args))).get("value")
+
+    async def relay_message(self, jid: str, message: dict[str, Any], options: dict[str, Any] | None = None) -> Any:
+        return await self.raw_request("relayMessage", jid, message, options or {})
+
+    async def send_presence(self, presence: str, to: str | None = None) -> Any:
+        return await self.raw_request("sendPresenceUpdate", presence, to)
+
+    async def read_messages(self, keys: list[dict[str, Any]]) -> Any:
+        return await self.raw_request("readMessages", keys)
+
+    async def check_number(self, numbers: list[str]) -> Any:
+        return await self.raw_request("onWhatsApp", numbers)
+
+    async def get_status(self, jid: str) -> Any:
+        return await self.raw_request("fetchStatus", jid)
+
+    async def get_profile_picture(self, jid: str, picture_type: str = "image") -> Any:
+        return await self.raw_request("profilePictureUrl", jid, picture_type)
+
+    async def get_blocklist(self) -> Any:
+        return await self.raw_request("fetchBlocklist")
+
+    async def update_profile_name(self, name: str) -> Any:
+        return await self.raw_request("updateProfileName", name)
+
+    async def update_profile_status(self, status: str) -> Any:
+        return await self.raw_request("updateProfileStatus", status)
+
+    async def update_profile_picture(self, jid: str, image: str | bytes) -> Any:
+        return await self.raw_request("updateProfilePicture", jid, image.decode() if isinstance(image, bytes) else image)
+
+    async def block(self, jid: str, action: str = "block") -> Any:
+        return await self.raw_request("updateBlockStatus", jid, action)
+
+    async def create_group(self, subject: str, participants: list[str]) -> Any:
+        return await self.raw_request("groupCreate", subject, participants)
+
+    async def get_group_info(self, jid: str) -> Any:
+        return await self.raw_request("groupMetadata", jid)
+
+    async def update_group_subject(self, jid: str, subject: str) -> Any:
+        return await self.raw_request("groupUpdateSubject", jid, subject)
+
+    async def update_group_description(self, jid: str, description: str) -> Any:
+        return await self.raw_request("groupUpdateDescription", jid, description)
+
+    async def update_group_participants(self, jid: str, participants: list[str], action: str) -> Any:
+        return await self.raw_request("groupParticipantsUpdate", jid, participants, action)
+
+    async def get_group_invite_code(self, jid: str) -> Any:
+        return await self.raw_request("groupInviteCode", jid)
+
+    async def revoke_group_invite(self, jid: str) -> Any:
+        return await self.raw_request("groupRevokeInvite", jid)
+
+    async def update_group_settings(self, jid: str, setting: str) -> Any:
+        return await self.raw_request("groupSettingUpdate", jid, setting)
+
+    async def accept_group_invite(self, code: str) -> Any:
+        return await self.raw_request("groupAcceptInvite", code)
+
+    async def logout(self) -> None:
+        await self._request("logout")
+        self._ready = False
+
+    async def close(self) -> None:
+        if self.alive:
+            try: await self._request("exit", timeout=5)
+            except BridgeError: pass
+        if self.process and self.process.returncode is None:
+            try: await asyncio.wait_for(self.process.wait(), 5)
+            except asyncio.TimeoutError: self.process.kill()
+        self._ready = False

x_nava-1.0.0/x_nava/engine.js

@@ -0,0 +1,80 @@
+const readline = require('readline');
+const makeWASocket = require('@whiskeysockets/baileys').default;
+const { useMultiFileAuthState, DisconnectReason, Browsers } = require('@whiskeysockets/baileys');
+
+const authDir = process.env.x_nava_AUTH_DIR || './auth';
+let sock = null;
+let ready = false;
+let stopping = false;
+
+function out(value) { process.stdout.write(JSON.stringify(value) + '\n'); }
+function errorMessage(e) { return String(e?.message || e); }
+function textOf(m) {
+  const c = m?.message || {};
+  return c.conversation || c.extendedTextMessage?.text || c.imageMessage?.caption || c.videoMessage?.caption || c.documentMessage?.caption;
+}
+function normalize(m) {
+  const jid = m?.key?.remoteJid || '';
+  return { id: m?.key?.id || '', chat_id: jid, sender_id: m?.key?.participant || (m?.key?.fromMe ? null : jid), from_me: !!m?.key?.fromMe, is_group: jid.endsWith('@g.us'), text: textOf(m), type: Object.keys(m?.message || {})[0] || 'unknown', timestamp: Number(m?.messageTimestamp || 0) || null, push_name: m?.pushName || null, raw: m };
+}
+
+async function start() {
+  const { state, saveCreds } = await useMultiFileAuthState(authDir);
+  sock = makeWASocket({ auth: state, printQRInTerminal: false, browser: Browsers.ubuntu('Chrome'), markOnlineOnConnect: false, syncFullHistory: false });
+  sock.ev.on('creds.update', saveCreds);
+  sock.ev.on('connection.update', ({ connection, lastDisconnect, qr }) => {
+    if (qr) out({ event: 'qr', data: qr });
+    if (connection === 'open') { ready = true; out({ event: 'ready', data: {} }); }
+    if (connection === 'close') {
+      ready = false;
+      const code = lastDisconnect?.error?.output?.statusCode || null;
+      out({ event: 'close', data: { code } });
+      if (!stopping && code !== DisconnectReason.loggedOut) setTimeout(() => start().catch(e => out({ event: 'error', data: { message: errorMessage(e) } })), 2000);
+    }
+  });
+  sock.ev.on('messages.upsert', ({ messages, type }) => out({ event: 'messages.upsert', data: { type, messages: messages.map(normalize) } }));
+  sock.ev.on('messages.update', updates => out({ event: 'messages.update', data: updates }));
+  sock.ev.on('groups.update', updates => out({ event: 'groups.update', data: updates }));
+  sock.ev.on('presence.update', update => out({ event: 'presence.update', data: update }));
+}
+
+async function command(c) {
+  if (c.action === 'status') return out({ request_id: c.request_id, ok: true, result: { ready, alive: true } });
+  if (c.action === 'start') return out({ request_id: c.request_id, ok: true, result: { starting: true } });
+  if (c.action === 'send_message') {
+    if (!sock || !ready) throw new Error('WhatsApp is not connected');
+    const jid = String(c.to).replace(/\D/g, '') + '@s.whatsapp.net';
+    const result = await sock.sendMessage(jid, c.content || { text: c.text });
+    return out({ request_id: c.request_id, ok: true, result: { id: result?.key?.id || null, to: jid } });
+  }
+  if (c.action === 'pairing_code') {
+    if (!sock) throw new Error('WhatsApp socket is not initialized');
+    return out({ request_id: c.request_id, ok: true, result: { code: await sock.requestPairingCode(String(c.phone).replace(/\D/g, '')) } });
+  }
+  if (c.action === 'baileys_call') {
+    if (!sock || !ready) throw new Error('WhatsApp is not connected');
+    const allowed = new Set([
+      'relayMessage', 'sendPresenceUpdate', 'readMessages', 'onWhatsApp',
+      'fetchStatus', 'profilePictureUrl', 'fetchBlocklist',
+      'updateProfileName', 'updateProfileStatus', 'updateProfilePicture',
+      'updateBlockStatus', 'groupCreate', 'groupMetadata',
+      'groupUpdateSubject', 'groupUpdateDescription',
+      'groupParticipantsUpdate', 'groupInviteCode', 'groupRevokeInvite',
+      'groupSettingUpdate', 'groupAcceptInvite', 'chatModify', 'presenceSubscribe'
+    ]);
+    if (!allowed.has(String(c.method)) || typeof sock[c.method] !== 'function') throw new Error('Unsupported Baileys method: ' + c.method);
+    const args = Array.isArray(c.args) ? c.args : [];
+    const value = await sock[c.method](...args);
+    return out({ request_id: c.request_id, ok: true, result: { value } });
+  }
+  if (c.action === 'logout') { stopping = true; await sock?.logout(); return out({ request_id: c.request_id, ok: true, result: {} }); }
+  if (c.action === 'exit') { stopping = true; sock?.end(undefined); out({ request_id: c.request_id, ok: true, result: {} }); process.exit(0); }
+  throw new Error('Unknown action: ' + c.action);
+}
+
+readline.createInterface({ input: process.stdin, crlfDelay: Infinity }).on('line', line => {
+  if (!line.trim()) return;
+  try { const c = JSON.parse(line); command(c).catch(e => out({ request_id: c.request_id, ok: false, error: { message: errorMessage(e) } })); }
+  catch (e) { out({ ok: false, error: { message: errorMessage(e) } }); }
+});
+start().catch(e => out({ event: 'error', data: { message: errorMessage(e) } }));

x_nava-1.0.0/x_nava/package.json

@@ -0,0 +1 @@
+{"private":true,"type":"commonjs","dependencies":{"@whiskeysockets/baileys":"6.7.24"}}

x_nava-1.0.0/x_nava/runtime/engine.js

@@ -0,0 +1,64 @@
+const readline = require('readline');
+const makeWASocket = require('@whiskeysockets/baileys').default;
+const { useMultiFileAuthState, DisconnectReason, Browsers } = require('@whiskeysockets/baileys');
+
+const authDir = process.env.x_nava_AUTH_DIR || './auth';
+let sock = null;
+let ready = false;
+let stopping = false;
+
+function out(value) { process.stdout.write(JSON.stringify(value) + '\n'); }
+function errorMessage(e) { return String(e?.message || e); }
+function textOf(m) {
+  const c = m?.message || {};
+  return c.conversation || c.extendedTextMessage?.text || c.imageMessage?.caption || c.videoMessage?.caption || c.documentMessage?.caption;
+}
+function normalize(m) {
+  const jid = m?.key?.remoteJid || '';
+  return { id: m?.key?.id || '', chat_id: jid, sender_id: m?.key?.participant || (m?.key?.fromMe ? null : jid), from_me: !!m?.key?.fromMe, is_group: jid.endsWith('@g.us'), text: textOf(m), type: Object.keys(m?.message || {})[0] || 'unknown', timestamp: Number(m?.messageTimestamp || 0) || null, push_name: m?.pushName || null, raw: m };
+}
+
+async function start() {
+  const { state, saveCreds } = await useMultiFileAuthState(authDir);
+  sock = makeWASocket({ auth: state, printQRInTerminal: false, browser: Browsers.ubuntu('Chrome'), markOnlineOnConnect: false, syncFullHistory: false });
+  sock.ev.on('creds.update', saveCreds);
+  sock.ev.on('connection.update', ({ connection, lastDisconnect, qr }) => {
+    if (qr) out({ event: 'qr', data: qr });
+    if (connection === 'open') { ready = true; out({ event: 'ready', data: {} }); }
+    if (connection === 'close') {
+      ready = false;
+      const code = lastDisconnect?.error?.output?.statusCode || null;
+      out({ event: 'close', data: { code } });
+      if (!stopping && code !== DisconnectReason.loggedOut) setTimeout(() => start().catch(e => out({ event: 'error', data: { message: errorMessage(e) } })), 2000);
+    }
+  });
+  sock.ev.on('messages.upsert', ({ messages, type }) => out({ event: 'messages.upsert', data: { type, messages: messages.map(normalize) } }));
+  sock.ev.on('messages.update', updates => out({ event: 'messages.update', data: updates }));
+  sock.ev.on('groups.update', updates => out({ event: 'groups.update', data: updates }));
+  sock.ev.on('presence.update', update => out({ event: 'presence.update', data: update }));
+}
+
+async function command(c) {
+  if (c.action === 'status') return out({ request_id: c.request_id, ok: true, result: { ready, alive: true } });
+  if (c.action === 'start') return out({ request_id: c.request_id, ok: true, result: { starting: true } });
+  if (c.action === 'send_message') {
+    if (!sock || !ready) throw new Error('WhatsApp is not connected');
+    const jid = String(c.to).replace(/\D/g, '') + '@s.whatsapp.net';
+    const result = await sock.sendMessage(jid, c.content || { text: c.text });
+    return out({ request_id: c.request_id, ok: true, result: { id: result?.key?.id || null, to: jid } });
+  }
+  if (c.action === 'pairing_code') {
+    if (!sock) throw new Error('WhatsApp socket is not initialized');
+    return out({ request_id: c.request_id, ok: true, result: { code: await sock.requestPairingCode(String(c.phone).replace(/\D/g, '')) } });
+  }
+  if (c.action === 'logout') { stopping = true; await sock?.logout(); return out({ request_id: c.request_id, ok: true, result: {} }); }
+  if (c.action === 'exit') { stopping = true; sock?.end(undefined); out({ request_id: c.request_id, ok: true, result: {} }); process.exit(0); }
+  throw new Error('Unknown action: ' + c.action);
+}
+
+readline.createInterface({ input: process.stdin, crlfDelay: Infinity }).on('line', line => {
+  if (!line.trim()) return;
+  try { const c = JSON.parse(line); command(c).catch(e => out({ request_id: c.request_id, ok: false, error: { message: errorMessage(e) } })); }
+  catch (e) { out({ ok: false, error: { message: errorMessage(e) } }); }
+});
+start().catch(e => out({ event: 'error', data: { message: errorMessage(e) } }));

x_nava-1.0.0/x_nava/runtime/package.json

@@ -0,0 +1 @@
+{"private":true,"type":"commonjs","dependencies":{"@whiskeysockets/baileys":"6.7.24"}}

x_nava-1.0.0/x_nava.egg-info/PKG-INFO

@@ -0,0 +1,58 @@
+Metadata-Version: 2.4
+Name: x-nava
+Version: 1.0.0
+Summary: Python-native messaging client with an embedded runtime
+Author: x_nava contributors
+License: MIT
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# x_nava for Python — Termux
+
+مكتبة Python للتعامل مع WhatsApp عبر Baileys. هذه النسخة مناسبة لـ **Termux على Android**: لا تستخدم Node.js المضمّن الخاص بسطح المكتب، بل تعتمد على Node.js الذي يثبّته Termux.
+
+> غير تابعة لـ WhatsApp أو Meta. استخدمها وفق القوانين وشروط الخدمة، ولا تستخدمها للسبام.
+
+## التثبيت على Termux
+
+```bash
+pkg update -y
+pkg install -y python nodejs-lts unzip
+unzip x_nava-1.0.0-termux.zip
+cd x_nava-1.0.0-termux
+python -m pip install --upgrade pip
+python -m pip install .
+```
+
+في أول تشغيل ستثبت المكتبة تلقائياً اعتماد Baileys داخل `~/.x_nava_runtime`. للتثبيت اليدوي:
+
+```bash
+cd ~/.x_nava_runtime
+npm install --no-audit --no-fund --save-exact
+```
+
+## مثال سريع
+
+```python
+import asyncio
+from x_nava import MoXstarClient
+
+async def main():
+    client = MoXstarClient(auth_dir='./auth')
+    client.on('qr', lambda code: print('QR:', code))
+    client.on('ready', lambda _: print('x_nava جاهزة'))
+    await client.start()
+    await client.wait_until_ready()
+    await client.wait_closed()
+
+asyncio.run(main())
+```
+
+يمكن تحديد مسار Node يدوياً عبر متغير البيئة `NAVAPRO_NODE`، لكن الوضع الافتراضي يستخدم `node` الموجود في Termux.
+
+## ملاحظات Android/Termux
+
+- استخدم `nodejs-lts` وليس نسخة Node مكتبية مضمّنة.
+- يفضّل تعطيل تحسين البطارية لتطبيق Termux حتى لا ينقطع الاتصال في الخلفية.
+- الاتصال الحي يحتاج QR أو Pairing Code ورقم WhatsApp حقيقي.
+- اختبارات Python المحلية لا تتصل بواتساب.

x_nava-1.0.0/x_nava.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+README.md
+pyproject.toml
+tests/test_client.py
+x_nava/__init__.py
+x_nava/client.py
+x_nava/engine.js
+x_nava/package.json
+x_nava.egg-info/PKG-INFO
+x_nava.egg-info/SOURCES.txt
+x_nava.egg-info/dependency_links.txt
+x_nava.egg-info/top_level.txt
+x_nava/runtime/engine.js
+x_nava/runtime/package.json

x_nava-1.0.0/x_nava.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

x_nava-1.0.0/x_nava.egg-info/top_level.txt

@@ -0,0 +1 @@
+x_nava