clapp-pm 1.0.18__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

@@ -12,252 +12,59 @@ Bu modül clapp paketlerinin güvenliğini sağlamak için:
 import os
 import json
 import hashlib
-import hmac
 import base64
-import tempfile
 import zipfile
-from pathlib import Path
-from typing import Dict, Tuple, Optional
+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 imzalama ve doğrulama sınıfı"""
-    
-    def __init__(self, private_key_path: Optional[str] = None, public_key_path: Optional[str] = None):
-        """
-        PackageSigner başlatıcısı
-        
-        Args:
-            private_key_path: Özel anahtar dosyası yolu
-            public_key_path: Genel anahtar dosyası yolu
-        """
-        self.private_key_path = private_key_path
-        self.public_key_path = public_key_path
-        self.private_key = None
-        self.public_key = None
-        
-        if private_key_path and os.path.exists(private_key_path):
-            self.load_private_key(private_key_path)
-        
-        if public_key_path and os.path.exists(public_key_path):
-            self.load_public_key(public_key_path)
-    
-    def generate_key_pair(self, key_size: int = 2048) -> Tuple[str, str]:
-        """
-        Yeni RSA anahtar çifti oluşturur
-        
-        Args:
-            key_size: Anahtar boyutu (varsayılan: 2048)
-            
-        Returns:
-            (private_key_path, public_key_path)
-        """
-        # Özel anahtar oluştur
-        private_key = rsa.generate_private_key(
-            public_exponent=65537,
-            key_size=key_size,
-            backend=default_backend()
-        )
-        
-        # Genel anahtar al
-        public_key = private_key.public_key()
-        
-        # Anahtarları kaydet
-        private_key_path = self._save_private_key(private_key)
-        public_key_path = self._save_public_key(public_key)
-        
-        return private_key_path, public_key_path
-    
-    def _save_private_key(self, private_key) -> str:
-        """Özel anahtarı dosyaya kaydet"""
-        key_path = os.path.join(os.path.expanduser("~"), ".clapp", "private_key.pem")
-        os.makedirs(os.path.dirname(key_path), exist_ok=True)
-        
-        with open(key_path, "wb") as f:
-            f.write(private_key.private_bytes(
-                encoding=serialization.Encoding.PEM,
-                format=serialization.PrivateFormat.PKCS8,
-                encryption_algorithm=serialization.NoEncryption()
-            ))
-        
-        return key_path
-    
-    def _save_public_key(self, public_key) -> str:
-        """Genel anahtarı dosyaya kaydet"""
-        key_path = os.path.join(os.path.expanduser("~"), ".clapp", "public_key.pem")
-        os.makedirs(os.path.dirname(key_path), exist_ok=True)
-        
-        with open(key_path, "wb") as f:
-            f.write(public_key.public_bytes(
-                encoding=serialization.Encoding.PEM,
-                format=serialization.PublicFormat.SubjectPublicKeyInfo
-            ))
-        
-        return key_path
-    
-    def load_private_key(self, key_path: str):
-        """Özel anahtarı dosyadan yükle"""
-        with open(key_path, "rb") as f:
-            self.private_key = serialization.load_pem_private_key(
-                f.read(),
-                password=None,
-                backend=default_backend()
-            )
-    
-    def load_public_key(self, key_path: str):
-        """Genel anahtarı dosyadan yükle"""
-        with open(key_path, "rb") as f:
-            self.public_key = serialization.load_pem_public_key(
-                f.read(),
-                backend=default_backend()
-            )
-    
+    """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 sign_package(self, package_path: str) -> Tuple[bool, str, Optional[str]]:
-        """
-        Paketi imzalar
-        
-        Args:
-            package_path: Paket dosyası yolu
-            
-        Returns:
-            (success, message, signature_path)
-        """
-        if not self.private_key:
-            return False, "Özel anahtar yüklenmedi", None
-        
-        try:
-            # Paket checksum'unu hesapla
-            checksum = self.calculate_checksum(package_path)
-            
-            # Manifest dosyasını oku
-            manifest_data = self._extract_manifest_data(package_path)
-            if not manifest_data:
-                return False, "Manifest dosyası bulunamadı", None
-            
-            # İmzalanacak veriyi hazırla
-            data_to_sign = {
-                "checksum": checksum,
-                "manifest": manifest_data,
-                "package_name": os.path.basename(package_path)
-            }
-            
-            data_string = json.dumps(data_to_sign, sort_keys=True)
-            data_bytes = data_string.encode('utf-8')
-            
-            # İmzala
-            signature = self.private_key.sign(
-                data_bytes,
-                padding.PSS(
-                    mgf=padding.MGF1(hashes.SHA256()),
-                    salt_length=padding.PSS.MAX_LENGTH
-                ),
-                hashes.SHA256()
-            )
-            
-            # İmzayı kaydet
-            signature_path = package_path.replace('.zip', '.sig')
-            with open(signature_path, 'wb') as f:
-                f.write(base64.b64encode(signature))
-            
-            return True, "Paket başarıyla imzalandı", signature_path
-            
-        except Exception as e:
-            return False, f"İmzalama hatası: {str(e)}", None
-    
-    def verify_package(self, package_path: str, signature_path: str) -> Tuple[bool, str]:
-        """
-        Paket imzasını doğrular
-        
-        Args:
-            package_path: Paket dosyası yolu
-            signature_path: İmza dosyası yolu
-            
-        Returns:
-            (is_valid, message)
-        """
-        if not self.public_key:
-            return False, "Genel anahtar yüklenmedi"
-        
-        try:
-            # İmzayı oku
-            with open(signature_path, 'rb') as f:
-                signature = base64.b64decode(f.read())
-            
-            # Paket checksum'unu hesapla
-            checksum = self.calculate_checksum(package_path)
-            
-            # Manifest dosyasını oku
-            manifest_data = self._extract_manifest_data(package_path)
-            if not manifest_data:
-                return False, "Manifest dosyası bulunamadı"
-            
-            # Doğrulanacak veriyi hazırla
-            data_to_verify = {
-                "checksum": checksum,
-                "manifest": manifest_data,
-                "package_name": os.path.basename(package_path)
-            }
-            
-            data_string = json.dumps(data_to_verify, sort_keys=True)
-            data_bytes = data_string.encode('utf-8')
-            
-            # İmzayı doğrula
-            self.public_key.verify(
-                signature,
-                data_bytes,
-                padding.PSS(
-                    mgf=padding.MGF1(hashes.SHA256()),
-                    salt_length=padding.PSS.MAX_LENGTH
-                ),
-                hashes.SHA256()
-            )
-            
-            return True, "Paket imzası doğrulandı"
-            
-        except Exception as e:
-            return False, f"İmza doğrulama hatası: {str(e)}"
-    
+
     def _extract_manifest_data(self, package_path: str) -> Optional[Dict]:
         """Paket içinden manifest verilerini çıkarır"""
         try:
@@ -267,23 +74,23 @@ class PackageSigner:
                     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)
         """
@@ -292,79 +99,50 @@ class PackageSigner:
             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)
+                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)}"
 
-# Yardımcı fonksiyonlar
-def create_package_signer() -> PackageSigner:
-    """Varsayılan ayarlarla PackageSigner oluşturur"""
-    clapp_dir = os.path.join(os.path.expanduser("~"), ".clapp")
-    private_key_path = os.path.join(clapp_dir, "private_key.pem")
-    public_key_path = os.path.join(clapp_dir, "public_key.pem")
-    
-    return PackageSigner(private_key_path, public_key_path)
-
-def sign_package_file(package_path: str) -> Tuple[bool, str]:
-    """Paket dosyasını imzalar"""
-    signer = create_package_signer()
-    
-    # Anahtar yoksa oluştur
-    if not signer.private_key:
-        print("🔑 Yeni anahtar çifti oluşturuluyor...")
-        private_key_path, public_key_path = signer.generate_key_pair()
-        signer.load_private_key(private_key_path)
-        print(f"✅ Anahtarlar oluşturuldu: {clapp_dir}")
-    
-    return signer.sign_package(package_path)
-
-def verify_package_file(package_path: str, signature_path: str) -> Tuple[bool, str]:
-    """Paket dosyasının imzasını doğrular"""
-    signer = create_package_signer()
-    return signer.verify_package(package_path, signature_path)
-
-def check_package_security(package_path: str) -> Dict[str, any]:
-    """Paket güvenlik kontrolü yapar"""
-    signer = create_package_signer()
-    
+
+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": False,
+        "signature": None,
         "checksum": "",
         "warnings": []
     }
-    
+
     # Bütünlük kontrolü
-    integrity_valid, integrity_msg = signer.verify_package_integrity(package_path)
+    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ü (varsa)
-    signature_path = package_path.replace('.zip', '.sig')
-    if os.path.exists(signature_path):
-        signature_valid, signature_msg = signer.verify_package(package_path, signature_path)
-        results["signature"] = signature_valid
-        
-        if not signature_valid:
-            results["warnings"].append(f"İmza hatası: {signature_msg}")
-    else:
-        results["warnings"].append("İmza dosyası bulunamadı")
-    
-    return results 
+
+    # İmza kontrolü kaldırıldı
+    results["signature"] = None
+
+    return results

templates/dart/manifest.json

@@ -0,0 +1,11 @@
+{
+  "name": "hello-dart",
+  "version": "1.0.0",
+  "language": "dart",
+  "entry": "main.dart",
+  "description": "Basit bir Dart Hello World uygulaması",
+  "author": "clapp Developer",
+  "license": "MIT",
+  "tags": ["example", "hello", "dart"],
+  "category": "demo"
+} 

templates/lua/manifest.json

@@ -0,0 +1,11 @@
+{
+  "name": "hello-lua",
+  "version": "1.0.0",
+  "language": "lua",
+  "entry": "main.lua",
+  "description": "Basit bir Lua Hello World uygulaması",
+  "author": "clapp Developer",
+  "license": "MIT",
+  "tags": ["example", "hello", "lua"],
+  "category": "demo"
+} 

templates/python/README.md

@@ -0,0 +1,51 @@
+# Hello Python - clapp Örnek Uygulaması
+
+Bu uygulama, clapp için Python uygulaması geliştirme örneğidir.
+
+## 🚀 Özellikler
+
+- Basit kullanıcı etkileşimi
+- Hata yönetimi
+- Sistem bilgileri gösterimi
+- Matematik işlemleri
+
+## 📦 Kurulum
+
+```bash
+# Uygulamayı yükle
+clapp install ./hello-python
+
+# Uygulamayı çalıştır
+clapp run hello-python
+```
+
+## 🧪 Test
+
+```bash
+# Uygulamayı doğrula
+clapp validate ./hello-python
+
+# Bağımlılıkları kontrol et
+clapp dependency check hello-python
+```
+
+## 📁 Dosya Yapısı
+
+```
+hello-python/
+├── manifest.json    # Uygulama manifesti
+├── main.py         # Ana uygulama dosyası
+└── README.md       # Bu dosya
+```
+
+## 🔧 Geliştirme
+
+Bu şablonu kendi uygulamanız için kullanabilirsiniz:
+
+1. `manifest.json` dosyasındaki `name` alanını değiştirin
+2. `main.py` dosyasını kendi kodunuzla değiştirin
+3. Gerekirse `requirements.txt` ekleyin
+
+## 📝 Lisans
+
+MIT License