clapp-pm 1.0.17__py3-none-any.whl → 1.0.19__py3-none-any.whl

package_runner.py

@@ -1,9 +1,93 @@
 import os
 import json
 import subprocess
+from typing import Dict, Callable, Optional, Tuple
 from package_registry import get_manifest
 
-def run_app(app_name):
+class LanguageRunner:
+    """Dil çalıştırıcıları için temel sınıf"""
+    
+    def __init__(self, name: str, command: str, file_extension: str = ""):
+        self.name = name
+        self.command = command
+        self.file_extension = file_extension
+    
+    def run(self, entry_file: str, app_path: str) -> Tuple[bool, str]:
+        """
+        Uygulamayı çalıştırır
+        
+        Args:
+            entry_file: Giriş dosyası
+            app_path: Uygulama dizini
+            
+        Returns:
+            (success, error_message)
+        """
+        try:
+            result = subprocess.run([self.command, entry_file], 
+                                  cwd=app_path, 
+                                  capture_output=False)
+            return result.returncode == 0, ""
+        except FileNotFoundError:
+            return False, f"{self.name} yüklü değil veya PATH'te bulunamadı."
+        except Exception as e:
+            return False, f"Çalıştırma hatası: {str(e)}"
+    
+    def check_availability(self) -> bool:
+        """Dil çalıştırıcısının sistemde mevcut olup olmadığını kontrol eder"""
+        try:
+            result = subprocess.run([self.command, "--version"], 
+                                  capture_output=True, 
+                                  text=True)
+            return result.returncode == 0
+        except FileNotFoundError:
+            return False
+
+# Desteklenen diller için runner'lar
+LANGUAGE_RUNNERS: Dict[str, LanguageRunner] = {
+    'python': LanguageRunner('Python', 'python', '.py'),
+    'lua': LanguageRunner('Lua', 'lua', '.lua'),
+    'dart': LanguageRunner('Dart', 'dart', '.dart'),
+    'go': LanguageRunner('Go', 'go', '.go'),
+    'rust': LanguageRunner('Rust', 'cargo', '.rs'),
+    'node': LanguageRunner('Node.js', 'node', '.js'),
+    'bash': LanguageRunner('Bash', 'bash', '.sh'),
+    'perl': LanguageRunner('Perl', 'perl', '.pl'),
+    'ruby': LanguageRunner('Ruby', 'ruby', '.rb'),
+    'php': LanguageRunner('PHP', 'php', '.php')
+}
+
+def get_runner_for_language(language: str) -> Optional[LanguageRunner]:
+    """
+    Dile göre runner döndürür
+    
+    Args:
+        language: Programlama dili
+        
+    Returns:
+        LanguageRunner veya None
+    """
+    return LANGUAGE_RUNNERS.get(language.lower())
+
+def add_language_support(name: str, command: str, file_extension: str = "") -> bool:
+    """
+    Yeni dil desteği ekler
+    
+    Args:
+        name: Dil adı
+        command: Çalıştırma komutu
+        file_extension: Dosya uzantısı
+        
+    Returns:
+        Başarılı ise True
+    """
+    try:
+        LANGUAGE_RUNNERS[name.lower()] = LanguageRunner(name, command, file_extension)
+        return True
+    except Exception:
+        return False
+
+def run_app(app_name: str) -> bool:
     """
     Belirtilen uygulamayı çalıştırır.
     
@@ -32,49 +116,33 @@ def run_app(app_name):
         print(f"Hata: Giriş dosyası '{entry_file}' bulunamadı.")
         return False
     
-    # Dile göre çalıştır
+    # Dile göre runner al
     language = manifest['language'].lower()
+    runner = get_runner_for_language(language)
     
-    try:
-        if language == 'python':
-            # Python uygulamasını çalıştır
-            result = subprocess.run(['python', entry_file], 
-                                  cwd=app_path, 
-                                  capture_output=False)
-            return result.returncode == 0
-            
-        elif language == 'lua':
-            # Lua uygulamasını çalıştır
-            result = subprocess.run(['lua', entry_file], 
-                                  cwd=app_path, 
-                                  capture_output=False)
-            return result.returncode == 0
-            
-        else:
-            print(f"Hata: Desteklenmeyen dil '{language}'. Desteklenen diller: python, lua")
-            return False
-            
-    except FileNotFoundError as e:
-        if language == 'python':
-            print("Hata: Python yüklü değil veya PATH'te bulunamadı.")
-        elif language == 'lua':
-            print("Hata: Lua yüklü değil veya PATH'te bulunamadı.")
-        return False
-        
-    except Exception as e:
-        print(f"Hata: Uygulama çalıştırılırken bir hata oluştu: {e}")
+    if not runner:
+        supported = ', '.join(LANGUAGE_RUNNERS.keys())
+        print(f"Hata: Desteklenmeyen dil '{language}'. Desteklenen diller: {supported}")
         return False
+    
+    # Uygulamayı çalıştır
+    success, error_msg = runner.run(entry_file, app_path)
+    
+    if not success and error_msg:
+        print(f"Hata: {error_msg}")
+    
+    return success
 
-def get_supported_languages():
+def get_supported_languages() -> list:
     """
     Desteklenen programlama dillerinin listesini döndürür.
     
     Returns:
         list: Desteklenen diller listesi
     """
-    return ['python', 'lua']
+    return list(LANGUAGE_RUNNERS.keys())
 
-def check_language_support(language):
+def check_language_support(language: str) -> bool:
     """
     Belirtilen dilin desteklenip desteklenmediğini kontrol eder.
     
@@ -84,4 +152,36 @@ def check_language_support(language):
     Returns:
         bool: Dil destekleniyorsa True, değilse False
     """
-    return language.lower() in get_supported_languages() 
+    return language.lower() in LANGUAGE_RUNNERS
+
+def check_language_availability(language: str) -> bool:
+    """
+    Belirtilen dilin sistemde mevcut olup olmadığını kontrol eder.
+    
+    Args:
+        language (str): Kontrol edilecek dil
+        
+    Returns:
+        bool: Dil mevcutsa True, değilse False
+    """
+    runner = get_runner_for_language(language)
+    if not runner:
+        return False
+    return runner.check_availability()
+
+def get_language_status_report() -> str:
+    """
+    Tüm desteklenen dillerin durum raporunu döndürür.
+    
+    Returns:
+        str: Formatlanmış durum raporu
+    """
+    report = "🌐 Desteklenen Diller Durumu\n"
+    report += "=" * 40 + "\n\n"
+    
+    for lang_name, runner in LANGUAGE_RUNNERS.items():
+        available = runner.check_availability()
+        status = "✅ Mevcut" if available else "❌ Mevcut Değil"
+        report += f"{lang_name.title():<12} : {status}\n"
+    
+    return report 

package_signing.py

@@ -0,0 +1,148 @@
+#!/usr/bin/env python3
+"""
+package_signing.py - Paket İmzalama ve Doğrulama Sistemi
+
+Bu modül clapp paketlerinin güvenliğini sağlamak için:
+- Paket imzalama
+- İmza doğrulama
+- Checksum hesaplama
+- Güvenlik kontrolü
+"""
+
+import os
+import json
+import hashlib
+import base64
+import zipfile
+from typing import Dict, Tuple, Optional, Any
+from cryptography.hazmat.primitives import hashes, serialization
+from cryptography.hazmat.primitives.asymmetric import rsa, padding
+from cryptography.hazmat.backends import default_backend
+
+
+class PackageSigner:
+    """Paket bütünlüğü ve checksum sınıfı (imzalama geçici olarak devre dışı)"""
+
+    def __init__(self):
+        pass
+
+    def calculate_checksum(self, file_path: str) -> str:
+        """
+        Dosyanın SHA-256 checksum'unu hesaplar
+
+        Args:
+            file_path: Dosya yolu
+
+        Returns:
+            SHA-256 hash (hex formatında)
+        """
+        sha256_hash = hashlib.sha256()
+
+        with open(file_path, "rb") as f:
+            for chunk in iter(lambda: f.read(4096), b""):
+                sha256_hash.update(chunk)
+
+        return sha256_hash.hexdigest()
+
+    def calculate_package_checksum(self, package_path: str) -> Dict[str, str]:
+        """
+        Paket içindeki tüm dosyaların checksum'unu hesaplar
+
+        Args:
+            package_path: Paket dosyası yolu (.zip)
+
+        Returns:
+            Dosya yolları ve checksum'ları
+        """
+        checksums = {}
+
+        with zipfile.ZipFile(package_path, 'r') as zip_file:
+            for file_info in zip_file.filelist:
+                if not file_info.is_dir():
+                    file_data = zip_file.read(file_info.filename)
+                    checksum = hashlib.sha256(file_data).hexdigest()
+                    checksums[file_info.filename] = checksum
+
+        return checksums
+
+    def _extract_manifest_data(self, package_path: str) -> Optional[Dict]:
+        """Paket içinden manifest verilerini çıkarır"""
+        try:
+            with zipfile.ZipFile(package_path, 'r') as zip_file:
+                # packages/ klasörü altındaki manifest.json'u ara
+                for file_info in zip_file.filelist:
+                    if file_info.filename.endswith('manifest.json'):
+                        manifest_data = zip_file.read(file_info.filename)
+                        return json.loads(manifest_data.decode('utf-8'))
+
+                # Doğrudan manifest.json'u ara
+                if 'manifest.json' in zip_file.namelist():
+                    manifest_data = zip_file.read('manifest.json')
+                    return json.loads(manifest_data.decode('utf-8'))
+
+                return None
+        except Exception:
+            return None
+
+    def verify_package_integrity(self, package_path: str) -> Tuple[bool, str]:
+        """
+        Paket bütünlüğünü kontrol eder
+
+        Args:
+            package_path: Paket dosyası yolu
+
+        Returns:
+            (is_valid, message)
+        """
+        try:
+            # ZIP dosyası geçerliliğini kontrol et
+            with zipfile.ZipFile(package_path, 'r') as zip_file:
+                # Dosya listesini kontrol et
+                file_list = zip_file.namelist()
+
+                # Manifest dosyası var mı?
+                has_manifest = any(
+                    f.endswith('manifest.json')
+                    for f in file_list
+                )
+                if not has_manifest:
+                    return False, "Manifest dosyası bulunamadı"
+
+                # Dosyaları test et
+                zip_file.testzip()
+
+                return True, "Paket bütünlüğü doğrulandı"
+
+        except zipfile.BadZipFile:
+            return False, "Geçersiz ZIP dosyası"
+        except Exception as e:
+            return False, f"Bütünlük kontrolü hatası: {str(e)}"
+
+
+def check_package_security(package_path: str) -> Dict[str, Any]:
+    """Paket güvenlik kontrolü yapar (imza kontrolü geçici olarak devre dışı)"""
+    signer = PackageSigner()
+
+    results = {
+        "integrity": False,
+        "signature": None,
+        "checksum": "",
+        "warnings": []
+    }
+
+    # Bütünlük kontrolü
+    integrity_valid, integrity_msg = signer.verify_package_integrity(
+        package_path
+    )
+    results["integrity"] = integrity_valid
+
+    if not integrity_valid:
+        results["warnings"].append(f"Bütünlük hatası: {integrity_msg}")
+
+    # Checksum hesapla
+    results["checksum"] = signer.calculate_checksum(package_path)
+
+    # İmza kontrolü kaldırıldı
+    results["signature"] = None
+
+    return results