openshell-shared 0.1.2__py3-none-any.whl

identity/store.py

@@ -0,0 +1,150 @@
+# shared/identity/store.py
+
+import json
+from pathlib import Path
+from typing import Any, Dict, Optional
+import os
+
+
+class IdentityStoreError(Exception):
+    pass
+
+
+class IdentityStore:
+    """
+    Generic filesystem-based identity vault.
+
+    Responsibilities:
+    - persist identity blobs (public/private)
+    - load identity blobs
+    - export safe/public view
+    - ensure structural consistency
+
+    It does NOT:
+    - generate identities
+    - perform cryptographic operations
+    - enforce business rules
+    """
+
+    def __init__(self, base_path: Path, namespace: str):
+        """
+        Args:
+            base_path: root storage path (e.g. storage/)
+            namespace: entity namespace (ra, osam, agent, proxy, etc.)
+        """
+
+        self._base = Path(base_path)
+        self._namespace = namespace
+
+        self._root = self._base / namespace / "identity"
+
+        self._public_path = self._root / "profile.public.json"
+        self._private_path = self._root / "profile.private.json"
+        self._meta_path = self._root / "metadata.json"
+
+        self._ensure_structure()
+
+    # ---------------------------------------------------------
+    # INTERNAL
+    # ---------------------------------------------------------
+    def _ensure_structure(self):
+        self._root.mkdir(parents=True, exist_ok=True)
+
+    def _write_json(self, path: Path, data: Dict[str, Any]):
+        tmp_path = path.with_suffix(".tmp")
+
+        with open(tmp_path, "w") as f:
+            json.dump(data, f, indent=4)
+
+        tmp_path.replace(path)
+
+    def _read_json(self, path: Path) -> Dict[str, Any]:
+        if not path.exists():
+            raise IdentityStoreError(f"Missing identity file: {path}")
+
+        with open(path, "r") as f:
+            return json.load(f)
+
+    # ---------------------------------------------------------
+    # LIFECYCLE
+    # ---------------------------------------------------------
+    def exists(self) -> bool:
+        print("CWD:", os.getcwd())
+        print("PUBLIC:", self._public_path)
+        print("PRIVATE:", self._private_path)
+
+        print("PUBLIC EXISTS:", self._public_path.exists())
+        print("PRIVATE EXISTS:", self._private_path.exists())
+
+        return self._public_path.exists() and self._private_path.exists()
+
+    def save(
+        self,
+        public_profile: Dict[str, Any],
+        private_profile: Dict[str, Any],
+        metadata: Optional[Dict[str, Any]] = None
+    ) -> None:
+        """
+        Persist identity bundle atomically.
+        """
+
+        self._write_json(self._public_path, public_profile)
+        self._write_json(self._private_path, private_profile)
+
+        if metadata is not None:
+            self._write_json(self._meta_path, metadata)
+
+    def load(self) -> Dict[str, Any]:
+        """
+        Load full identity bundle.
+        """
+
+        return {
+            "public": self._read_json(self._public_path),
+            "private": self._read_json(self._private_path),
+            "metadata": (
+                self._read_json(self._meta_path)
+                if self._meta_path.exists()
+                else None
+            )
+        }
+
+    def load_public(self) -> Dict[str, Any]:
+        return self._read_json(self._public_path)
+
+    def load_private(self) -> Dict[str, Any]:
+        return self._read_json(self._private_path)
+
+    # ---------------------------------------------------------
+    # EXPORT (SAFE)
+    # ---------------------------------------------------------
+    def export_public(self, export_path: Path) -> Path:
+        """
+        Export only public identity (safe for sharing).
+        """
+
+        data = self.load_public()
+
+        export_path = Path(export_path)
+        export_path.mkdir(parents=True, exist_ok=True)
+
+        file_path = export_path / f"{self._namespace}.identity.public.json"
+
+        with open(file_path, "w") as f:
+            json.dump(data, f, indent=4)
+
+        return file_path
+
+    # ---------------------------------------------------------
+    # DELETE (optional, destructive)
+    # ---------------------------------------------------------
+    def delete(self) -> None:
+        """
+        Remove identity completely.
+        """
+
+        if self._root.exists():
+            for file in self._root.glob("*"):
+                file.unlink()
+
+            self._root.rmdir()

modules/shell/client.py

@@ -0,0 +1,361 @@
+# shell/client.py
+
+# =====================================================
+# LIBRARY IMPORTS
+# =====================================================
+
+import os
+import tty
+import termios
+import asyncio
+import traceback
+
+from .protocol import ShellProtocol
+from .models import (
+    ProtocolType,
+    ProtocolStandard,
+    ShellSignal
+)
+
+
+# =====================================================
+# SHELL CLIENT
+# =====================================================
+
+class ShellClient:
+
+    def __init__(
+        self,
+        communication_handler,
+        auth_token: str,
+        tunnel_token: str,
+        session_token: str
+    ):
+
+        self._communication_handler = (
+            communication_handler
+        )
+
+        self._auth_token = auth_token
+        self._tunnel_token = tunnel_token
+        self._session_token = session_token
+
+        self._is_running = False
+
+        self._shell_protocol = ShellProtocol(
+            auth_token=self._auth_token,
+            tunnel_token=self._tunnel_token,
+            session_token=self._session_token
+        )
+
+        self._stdin_fd = (
+            os.sys.stdin.fileno()
+        )
+
+        self._old_term = None
+
+    # =================================================
+    # START
+    # =================================================
+
+    async def start(self):
+
+        self._is_running = True
+
+        print(
+            "[SHELL] Opening PTY..."
+        )
+
+        await (
+            self._communication_handler
+            .send_datapackage(
+                self._shell_protocol.open()
+            )
+        )
+
+        self._enable_raw_mode()
+
+        try:
+
+            receiver_task = (
+                asyncio.create_task(
+                    self._receiver_loop()
+                )
+            )
+
+            sender_task = (
+                asyncio.create_task(
+                    self._sender_loop()
+                )
+            )
+
+            done, pending = (
+                await asyncio.wait(
+                    [
+                        receiver_task,
+                        sender_task
+                    ],
+                    return_when=
+                    asyncio.FIRST_COMPLETED
+                )
+            )
+
+            for task in pending:
+
+                task.cancel()
+
+        finally:
+
+            self._disable_raw_mode()
+
+            try:
+
+                await (
+                    self._communication_handler
+                    .send_datapackage(
+                        self._shell_protocol.close()
+                    )
+                )
+
+            except Exception:
+
+                pass
+
+            self._is_running = False
+
+            print(
+                "\n[SHELL] Closed"
+            )
+
+    # =================================================
+    # RAW MODE
+    # =================================================
+
+    def _enable_raw_mode(self):
+
+        self._old_term = (
+            termios.tcgetattr(
+                self._stdin_fd
+            )
+        )
+
+        tty.setraw(
+            self._stdin_fd
+        )
+
+    def _disable_raw_mode(self):
+
+        if self._old_term:
+
+            termios.tcsetattr(
+                self._stdin_fd,
+                termios.TCSADRAIN,
+                self._old_term
+            )
+
+    # =================================================
+    # RECEIVER
+    # =================================================
+
+    async def _receiver_loop(self):
+
+        while self._is_running:
+
+            try:
+
+                packet = await (
+                    self._communication_handler
+                    .receive_datapackage()
+                )
+
+                if not isinstance(
+                    packet,
+                    dict
+                ):
+                    continue
+
+                payload = packet.get(
+                    "payload",
+                    {}
+                )
+
+                if (
+                    payload.get(
+                        "protocol"
+                    )
+                    !=
+                    ProtocolStandard
+                    .SHELL
+                    .value
+                ):
+                    continue
+
+                if (
+                    payload.get(
+                        "protocol_type"
+                    )
+                    !=
+                    ProtocolType
+                    .SERVER
+                    .value
+                ):
+                    continue
+
+                event = payload.get(
+                    "event"
+                )
+
+                # -------------------------
+                # OUTPUT
+                # -------------------------
+
+                if event == "OUTPUT":
+
+                    data = payload.get(
+                        "data",
+                        ""
+                    )
+
+                    if data:
+
+                        print(
+                            data,
+                            end="",
+                            flush=True
+                        )
+
+                    continue
+
+                # -------------------------
+                # EXIT
+                # -------------------------
+
+                if event == "EXIT":
+
+                    code = payload.get(
+                        "return_code",
+                        0
+                    )
+
+                    print(
+                        f"\n\r"
+                        f"[REMOTE EXIT {code}]"
+                    )
+
+                    self.stop()
+
+                    break
+
+            except asyncio.CancelledError:
+
+                break
+
+            except Exception:
+
+                print(
+                    "\n[SHELL-CLIENT] "
+                    "Receiver exception:"
+                )
+
+                traceback.print_exc()
+
+                self.stop()
+
+                break
+
+    # =================================================
+    # SENDER
+    # =================================================
+
+    async def _sender_loop(self):
+
+        loop = (
+            asyncio.get_running_loop()
+        )
+
+        while self._is_running:
+
+            try:
+
+                data = await (
+                    loop.run_in_executor(
+                        None,
+                        os.read,
+                        self._stdin_fd,
+                        1024
+                    )
+                )
+
+                if not data:
+                    continue
+
+                # -------------------------
+                # CTRL+C
+                # -------------------------
+
+                if data == b"\x03":
+
+                    await (
+                        self._communication_handler
+                        .send_datapackage(
+                            self._shell_protocol.signal(
+                                ShellSignal
+                                .SIGINT
+                                .value
+                            )
+                        )
+                    )
+
+                    continue
+
+                # -------------------------
+                # CTRL+D
+                # -------------------------
+
+                if data == b"\x04":
+
+                    self.stop()
+
+                    break
+
+                # -------------------------
+                # INPUT
+                # -------------------------
+
+                await (
+                    self._communication_handler
+                    .send_datapackage(
+                        self._shell_protocol.input(
+                            data.decode(
+                                errors="ignore"
+                            )
+                        )
+                    )
+                )
+
+            except asyncio.CancelledError:
+
+                break
+
+            except Exception:
+
+                print(
+                    "\n[SHELL-CLIENT] "
+                    "Sender exception:"
+                )
+
+                traceback.print_exc()
+
+                self.stop()
+
+                break
+
+    # =================================================
+    # STOP
+    # =================================================
+
+    def stop(self):
+
+        self._is_running = False
+
+        return True

modules/shell/models.py

@@ -0,0 +1,61 @@
+# shell/models.py
+
+# =====================================================
+# LIBRARY IMPORTS
+# =====================================================
+
+from enum import Enum
+
+
+# =====================================================
+# PROTOCOL TYPE
+# =====================================================
+
+class ProtocolType(str, Enum):
+
+    CLIENT = "CLIENT"
+    SERVER = "SERVER"
+
+
+# =====================================================
+# PROTOCOL STANDARD
+# =====================================================
+
+class ProtocolStandard(str, Enum):
+
+    SHELL = "SHELL"
+    FTP = "FTP"
+    SPECIAL = "SPECIAL"
+
+
+# =====================================================
+# SHELL EVENTS
+# =====================================================
+
+class ShellEvent(str, Enum):
+
+    OPEN = "OPEN"
+
+    INPUT = "INPUT"
+
+    OUTPUT = "OUTPUT"
+
+    RESIZE = "RESIZE"
+
+    SIGNAL = "SIGNAL"
+
+    CLOSE = "CLOSE"
+
+
+# =====================================================
+# SHELL SIGNALS
+# =====================================================
+
+class ShellSignal(str, Enum):
+
+    SIGINT = "SIGINT"
+    SIGTERM = "SIGTERM"
+    SIGKILL = "SIGKILL"
+    SIGHUP = "SIGHUP"
+    SIGQUIT = "SIGQUIT"
+    SIGTSTP = "SIGTSTP"