Upload secure_launcher_v2.py

runtime-patches/5.5.10/runtime/secure_launcher_v2.py

@@ -0,0 +1,703 @@
+#!/usr/bin/env python3
+"""
+AutoMosaRakku セキュアランチャー（改良版）
+"""
+
+import os
+import sys
+import tempfile
+import shutil
+from pathlib import Path
+import pickle
+import traceback
+from datetime import datetime
+import logging
+import time
+
+_STARTUP_TOTAL_START = time.perf_counter()
+_STARTUP_TIMING_ENABLED = os.environ.get('AUTOMOSA_STARTUP_TIMING') == '1'
+APP_DIR_ENV = 'AUTOMOSA_APP_DIR'
+SAM2_CHECKPOINT_PROVIDER_ENV = 'AUTOMOSA_SAM2_CHECKPOINT_PROVIDER'
+SAM2_CHECKPOINT_REL_PATHS = {
+    'tiny': 'sam2/sam2.1_hiera_tiny.pt',
+}
+_sam2_checkpoint_buffers = {}
+
+# コンソール出力を抑制（Tritonコンパイル時のちらつき防止）
+try:
+    # 物体削除初回推論時のコンソールちらつきを完全に防ぐ
+    # pythonw起動ではstdout/stderrがNoneになり、tqdm等がwriteした瞬間に
+    # AttributeErrorで落ちるため、必ず書き込み可能なストリームを保証する
+    if sys.stdout is None:
+        sys.stdout = open(os.devnull, 'w', encoding='utf-8')
+    if sys.stderr is None:
+        sys.stderr = open(os.devnull, 'w', encoding='utf-8')
+    if not hasattr(sys, '_original_stdout'):
+        sys._original_stdout = sys.stdout
+        sys._original_stderr = sys.stderr
+
+    # 環境変数でも出力を抑制
+    os.environ['PYTHONIOENCODING'] = 'utf-8'
+    os.environ['PYTHONUNBUFFERED'] = '0'
+
+except:
+    pass
+
+# CRITICAL: 組み込みPython環境を強制設定（ランチャー起動直後）
+script_dir = Path(__file__).parent.parent
+python_base_dir = script_dir / "python_base"
+os.environ[APP_DIR_ENV] = str(script_dir)
+
+
+def _normalize_resource_path(relative_path):
+    return str(relative_path).replace('\\', '/')
+
+
+def _register_sam2_checkpoint_buffer(relative_path, content):
+    normalized_path = _normalize_resource_path(relative_path)
+    for model_size, checkpoint_path in SAM2_CHECKPOINT_REL_PATHS.items():
+        if normalized_path == checkpoint_path:
+            _sam2_checkpoint_buffers[model_size] = bytes(content)
+            return True
+    return False
+
+
+def get_sam2_checkpoint_bytes(model_size='tiny'):
+    content = _sam2_checkpoint_buffers.get(model_size)
+    if content is None:
+        return None
+    return bytes(content)
+
+
+def _startup_log_path(root_dir):
+    log_dir = root_dir / "logs"
+    return log_dir / f"startup_timing_{datetime.now().strftime('%Y%m%d')}.log"
+
+
+def _startup_phase_start():
+    return time.perf_counter()
+
+
+def _startup_log_phase(root_dir, phase, phase_start):
+    if not _STARTUP_TIMING_ENABLED:
+        return
+    now = time.perf_counter()
+    message = (
+        f"[STARTUP] phase={phase} event=end "
+        f"elapsed_ms={(now - phase_start) * 1000:.3f} "
+        f"total_ms={(now - _STARTUP_TOTAL_START) * 1000:.3f}"
+    )
+    try:
+        log_file = _startup_log_path(root_dir)
+        log_file.parent.mkdir(exist_ok=True)
+        with open(log_file, "a", encoding="utf-8") as f:
+            f.write(message + "\n")
+    except Exception:
+        pass
+
+# 環境変数を強制設定
+if python_base_dir.exists():
+    # print(f"[ENVIRONMENT ISOLATION] Configuring embedded Python...")
+    # print(f"[ENVIRONMENT CHECK] Python paths:")
+    # print(f"  PYTHONHOME: {python_base_dir}")
+    # print(f"  INCLUDE: {python_base_dir / 'include'}")
+    # print(f"  LIB: {python_base_dir / 'libs'}")
+    
+    # Python関連環境変数を完全にクリア（最初に実行）
+    python_env_vars = ['PYTHONPATH', 'PYTHONHOME', 'VIRTUAL_ENV', 'CONDA_DEFAULT_ENV', 'CONDA_PREFIX', 'PYENV_ROOT', 'PYENV_VERSION']
+    for env_var in python_env_vars:
+        if env_var in os.environ:
+            del os.environ[env_var]
+            # print(f"[ENV CLEAR] Removed {env_var}")
+    
+    # PATHからPython関連のパスを除去（VC++は保持）
+    path_env = os.environ.get('PATH', '')
+    filtered_paths = []
+    for p in path_env.split(os.pathsep):
+        # VC++/MSVCパスは保持
+        if 'microsoft visual studio' in p.lower() or 'msvc' in p.lower() or 'windows kits' in p.lower():
+            filtered_paths.append(p)
+            # print(f"[PATH KEEP] Preserved VC++: {p}")
+        # Python関連パスをフィルタリング
+        elif any(keyword in p.lower() for keyword in [
+            'pyenv', 'python', 'anaconda', 'miniconda', 'conda', 'venv', 'virtualenv'
+        ]):
+            # print(f"[PATH FILTER] Excluded: {p}")
+            pass
+        else:
+            filtered_paths.append(p)
+    
+    # 埋め込みPythonパスを先頭に追加
+    filtered_paths.insert(0, str(python_base_dir))
+    filtered_paths.insert(1, str(python_base_dir / 'Scripts'))
+    os.environ['PATH'] = os.pathsep.join(filtered_paths)
+    # print(f"[PATH UPDATE] New PATH starts with: {filtered_paths[0]}")
+    
+    # 埋め込みPython環境を強制設定
+    os.environ['PYTHONHOME'] = str(python_base_dir)
+    os.environ['PYTHONPATH'] = f"{python_base_dir / 'Lib'};{python_base_dir / 'Lib' / 'site-packages'}"
+    
+    # INCLUDE/LIB環境変数を拡張（上書きではなく追加）
+    # VC++のヘッダー/ライブラリパスを保持
+    existing_include = os.environ.get('INCLUDE', '')
+    existing_lib = os.environ.get('LIB', '')
+    
+    # Python埋め込み版のパスを先頭に追加
+    os.environ['INCLUDE'] = f"{python_base_dir / 'include'};{existing_include}" if existing_include else str(python_base_dir / 'include')
+    os.environ['LIB'] = f"{python_base_dir / 'libs'};{existing_lib}" if existing_lib else str(python_base_dir / 'libs')
+    
+    # MinGW-w64環境を設定（stdlib.h問題の解決）
+    mingw_dir = script_dir / "mingw64"
+    if mingw_dir.exists():
+        # print(f"[MINGW] Configuring MinGW-w64 compiler environment...")
+        # MinGWのbinをPATHに追加
+        os.environ['PATH'] = f"{mingw_dir / 'bin'};" + os.environ.get('PATH', '')
+        # コンパイラの設定
+        os.environ['CC'] = str(mingw_dir / 'bin' / 'gcc.exe')
+        os.environ['CXX'] = str(mingw_dir / 'bin' / 'g++.exe')
+        # インクルードパスの設定（stdlib.hを含む）
+        os.environ['C_INCLUDE_PATH'] = f"{mingw_dir / 'include'};{mingw_dir / 'x86_64-w64-mingw32' / 'include'}"
+        os.environ['CPLUS_INCLUDE_PATH'] = f"{mingw_dir / 'include'};{mingw_dir / 'x86_64-w64-mingw32' / 'include'}"
+        # Python libsディレクトリを最初に追加（libpython311.aのため）
+        os.environ['LIBRARY_PATH'] = f"{python_base_dir / 'libs'};{mingw_dir / 'lib'};{mingw_dir / 'x86_64-w64-mingw32' / 'lib'}"
+        # Tritonが確実に認識できるよう追加の環境変数も設定
+        os.environ['LDFLAGS'] = f"-L{python_base_dir / 'libs'} -L{mingw_dir / 'lib'}"
+        # Triton用の設定
+        os.environ['TRITON_PTXAS_PATH'] = str(mingw_dir / 'bin')
+        os.environ['TRITON_CUOBJDUMP_PATH'] = str(mingw_dir / 'bin')
+        # print(f"[MINGW] MinGW-w64 configured at: {mingw_dir}")
+    
+    # sys.pathを調整（完全にクリアせずに必要なパスを前に追加）
+    # print(f"[SYS.PATH] Original sys.path length: {len(sys.path)}")
+    # 必要なパスを前に追加（標準ライブラリを保持）
+    new_paths = [
+        str(python_base_dir / 'Lib' / 'site-packages'),
+        str(python_base_dir / 'Lib'),
+        str(python_base_dir / 'DLLs'),
+        str(python_base_dir),
+        str(python_base_dir / 'Scripts')
+    ]
+    # 既存のパスから重複を除去して追加
+    for path in new_paths:
+        if path not in sys.path:
+            sys.path.insert(0, path)
+    # print(f"[SYS.PATH] New sys.path length: {len(sys.path)}")
+    # print(f"[SYS.PATH] First entry: {sys.path[0]}")
+    
+    # sys属性の強制更新
+    original_executable = sys.executable
+    sys.executable = str(python_base_dir / 'python.exe')
+    sys.prefix = str(python_base_dir)
+    sys.exec_prefix = str(python_base_dir)
+    sys.base_prefix = str(python_base_dir)
+    sys.base_exec_prefix = str(python_base_dir)
+    
+    # print(f"[SYS UPDATE] executable: {original_executable} -> {sys.executable}")
+    # print(f"[SYS UPDATE] prefix: {sys.prefix}")
+    # print(f"[SYS UPDATE] exec_prefix: {sys.exec_prefix}")
+    
+    # 環境分離完了後のランタイム情報を出力
+    # print(f"[RUNTIME] Python: {sys.executable}")
+    # print(f"[RUNTIME] sys.prefix: {sys.prefix}")
+
+_startup_log_phase(script_dir, "env", _STARTUP_TOTAL_START)
+
+# ログ設定（無効化 - 配布版では不要）
+# log_dir = Path(__file__).parent.parent / "logs"
+# log_dir.mkdir(exist_ok=True)
+# log_file = log_dir / f"launcher_{datetime.now().strftime('%Y%m%d_%H%M%S')}.log"
+
+# logging.basicConfig(
+#     level=logging.INFO,
+#     format='%(asctime)s - %(levelname)s - %(message)s',
+#     handlers=[
+#         logging.FileHandler(log_file, encoding='utf-8')
+#         # StreamHandler()はコンソールウィンドウのちらつきを引き起こすため配布版では無効化
+#     ]
+# )
+# logger = logging.getLogger(__name__)
+
+
+class SplashWindow:
+    """起動スプラッシュウィンドウ"""
+    
+    def __init__(self, initial_message="オートモザラック 起動中..."):
+        try:
+            from PySide6.QtWidgets import QApplication, QWidget, QLabel, QVBoxLayout
+            from PySide6.QtCore import Qt
+            from PySide6.QtGui import QFont
+            
+            self.app = QApplication.instance()
+            if self.app is None:
+                self.app = QApplication([])
+            
+            self.window = QWidget()
+            self.window.setWindowTitle("オートモザラック")
+            self.window.setFixedSize(300, 120)
+            self.window.setWindowFlags(Qt.WindowStaysOnTopHint | Qt.FramelessWindowHint)
+            
+            # レイアウト
+            layout = QVBoxLayout()
+            
+            # タイトル
+            title_label = QLabel("オートモザラック")
+            title_font = QFont()
+            title_font.setPointSize(14)
+            title_font.setBold(True)
+            title_label.setFont(title_font)
+            title_label.setAlignment(Qt.AlignCenter)
+            
+            # メッセージ
+            self.message_label = QLabel(initial_message)
+            self.message_label.setAlignment(Qt.AlignCenter)
+            
+            layout.addWidget(title_label)
+            layout.addWidget(self.message_label)
+            
+            self.window.setLayout(layout)
+            
+            # ウィンドウを中央に配置
+            self.center_window()
+            
+        except ImportError:
+            # PySide6が利用できない場合は何もしない
+            self.window = None
+            self.app = None
+    
+    def center_window(self):
+        """ウィンドウを画面中央に配置"""
+        if self.window:
+            from PySide6.QtWidgets import QApplication
+            screen = QApplication.primaryScreen()
+            if screen:
+                screen_geometry = screen.geometry()
+                x = (screen_geometry.width() - self.window.width()) // 2
+                y = (screen_geometry.height() - self.window.height()) // 2
+                self.window.move(x, y)
+    
+    def show(self):
+        """ウィンドウを表示"""
+        if self.window:
+            self.window.show()
+            if self.app:
+                self.app.processEvents()
+    
+    def update_message(self, message):
+        """メッセージを更新"""
+        if self.message_label:
+            self.message_label.setText(message)
+            if self.app:
+                self.app.processEvents()
+    
+    def close(self):
+        """ウィンドウを閉じる"""
+        if self.window:
+            self.window.close()
+
+
+def _g():
+    """動的にキーを生成（難読化）"""
+    # 難読化されたキーデータ
+    _K = [
+        ([112, 168, 206, 174], [244, 79, 138, 205]),
+        ([8, 221, 134, 194], [103, 94, 24, 115]),
+        ([151, 237, 49, 38], [184, 61, 85, 242]),
+        ([102, 4, 23, 41], [49, 0, 12, 198]),
+        ([168, 53, 47, 55], [171, 147, 249, 73]),
+        ([169, 62, 88, 214], [154, 100, 243, 135]),
+        ([223, 112, 79, 121], [87, 178, 205, 68]),
+        ([122, 185, 192, 39], [32, 16, 99, 61]),
+    ]
+    
+    # キーの各部分を復元
+    key_bytes = bytearray()
+    
+    for obf, xor in _K:
+        # XORで元のデータを復元
+        chunk = bytes(a ^ b for a, b in zip(obf, xor))
+        key_bytes.extend(chunk)
+    
+    # Base64エンコード
+    import base64
+    return base64.urlsafe_b64encode(bytes(key_bytes))
+
+
+class D:
+    """復号化クラス"""
+    
+    def __init__(self):
+        from cryptography.fernet import Fernet
+        self.f = Fernet(_g())
+    
+    def d(self, i, o):
+        """ディレクトリを復号化（シンプル版）"""
+        with open(i, 'rb') as f:
+            e = f.read()
+        
+        # 復号化
+        s = self.f.decrypt(e)
+        
+        # デシリアライズ
+        data = pickle.loads(s)
+        
+        # ファイル復元
+        for rel_path, content in data.items():
+            out_path = os.path.join(o, rel_path)
+            os.makedirs(os.path.dirname(out_path), exist_ok=True)
+            with open(out_path, 'wb') as f:
+                f.write(content)
+
+
+def clear_triton_cache():
+    """Tritonキャッシュを削除してコンパイル失敗を避ける"""
+    import shutil
+    try:
+        cache_dirs = []
+        
+        # Windows標準キャッシュディレクトリ
+        if os.name == 'nt':
+            # os.path.expanduser を使用（埋め込み版でも利用可能）
+            home = os.path.expanduser('~')
+            username = os.environ.get('USERNAME', '')
+            localappdata = os.environ.get('LOCALAPPDATA', '')
+            
+            if home:
+                cache_dirs.append(os.path.join(home, '.triton', 'cache'))
+            if localappdata and username:
+                cache_dirs.append(os.path.join(localappdata, 'Temp', f'torchinductor_{username}'))
+        
+        # print("Windows標準キャッシュディレクトリを使用:")
+        for cache_dir in cache_dirs:
+            cache_dir_name = os.path.basename(os.path.dirname(cache_dir))
+            # print(f"  {cache_dir_name}: {cache_dir}")
+            if os.path.exists(cache_dir):
+                try:
+                    shutil.rmtree(cache_dir, ignore_errors=True)
+                    # print(f"[CACHE] Cleared: {cache_dir}")
+                except Exception as e:
+                    # print(f"[CACHE] Failed to clear {cache_dir}: {e}")
+                    pass
+            else:
+                # print(f"[CACHE] Not found: {cache_dir}")
+                pass
+    except Exception as e:
+        # print(f"[CACHE ERROR] Failed to clear Triton cache: {e}")
+        # キャッシュクリアに失敗してもアプリ起動は続行
+        pass
+
+
+def configure_embedded_environment(exe_dir):
+    """埋め込みPython環境の再設定とTriton用の追加設定"""
+    python_base_dir = exe_dir / "python_base"
+    mingw_dir = exe_dir / "mingw64"
+    os.environ[APP_DIR_ENV] = str(exe_dir)
+    
+    if not python_base_dir.exists():
+        # print(f"[ERROR] Python base directory not found: {python_base_dir}")
+        return
+    
+    # 暗号化環境のメモリベースモデルアクセス環境変数を設定
+    os.environ['AUTOMOSA_MEMORY_MODELS'] = '1'
+    
+    # Tritonコンパイラ用の環境変数を追加設定
+    if mingw_dir.exists():
+        # print(f"[MINGW EXTENDED] Configuring extended MinGW-w64 environment for Triton...")
+        
+        # 基本的なMinGW-w64ライブラリパス（標準ランタイムオブジェクト用）
+        lib_dirs = [
+            mingw_dir / "x86_64-w64-mingw32" / "lib",
+            mingw_dir / "lib" / "gcc" / "x86_64-w64-mingw32" / "15.2.0",
+            mingw_dir / "lib",
+            python_base_dir / "libs"  # libpython311.a用
+        ]
+        
+        # 存在するライブラリパスのみを環境変数に設定
+        valid_lib_paths = [str(lib_dir) for lib_dir in lib_dirs if lib_dir.exists()]
+        
+        # 環境変数の更新
+        os.environ['LIBRARY_PATH'] = os.pathsep.join(valid_lib_paths)
+        os.environ['LD_LIBRARY_PATH'] = os.pathsep.join(valid_lib_paths)  # Linux style too
+        
+        # LDFLAGS更新（-Lフラグを明示的に追加）
+        ldflags = " ".join([f"-L{path}" for path in valid_lib_paths])
+        os.environ['LDFLAGS'] = ldflags
+        
+        # CFLAGS/CXXFLAGS追加設定
+        cflags = f"-I{python_base_dir / 'include'} -I{mingw_dir / 'include'} -I{mingw_dir / 'x86_64-w64-mingw32' / 'include'}"
+        os.environ['CFLAGS'] = cflags
+        os.environ['CXXFLAGS'] = cflags
+        
+        # print(f"[MINGW EXTENDED] LIBRARY_PATH set to: {os.environ['LIBRARY_PATH']}")
+        # print(f"[MINGW EXTENDED] LDFLAGS set to: {os.environ['LDFLAGS']}")
+        
+        # Triton用の追加環境変数
+        os.environ['TRITON_CC'] = str(mingw_dir / 'bin' / 'gcc.exe')
+        os.environ['TRITON_CXX'] = str(mingw_dir / 'bin' / 'g++.exe')
+        
+        # MinGW-w64用のTriton Windows utilities設定
+        os.environ['TRITON_LIBDIR'] = os.pathsep.join(valid_lib_paths)
+        
+        # 【重要】TritonがPythonライブラリを確実に見つけるため、libpython311.aをTritonの期待する場所にコピー
+        try:
+            import shutil
+            site_packages = python_base_dir / "Lib" / "site-packages"
+            if site_packages.exists():
+                triton_lib_paths = [
+                    site_packages / "triton" / "backends" / "nvidia" / "lib",
+                    site_packages / "triton" / "backends" / "nvidia" / "lib" / "x64"
+                ]
+                
+                libpython_source = python_base_dir / "libs" / "libpython311.a"
+                if libpython_source.exists():
+                    for target_dir in triton_lib_paths:
+                        if target_dir.exists():
+                            target_file = target_dir / "libpython311.a"
+                            if not target_file.exists():
+                                shutil.copy2(str(libpython_source), str(target_file))
+                                # print(f"[TRITON FIX] Copied libpython311.a to: {target_file}")
+                            
+                            # MinGW-w64ランタイムライブラリもコピー
+                            mingw_runtime_libs = [
+                                "libmingw32.a", "libgcc.a", "libgcc_s.a"
+                            ]
+                            
+                            for lib_name in mingw_runtime_libs:
+                                for mingw_lib_dir in [mingw_dir / "lib", mingw_dir / "x86_64-w64-mingw32" / "lib"]:
+                                    source_lib = mingw_lib_dir / lib_name
+                                    if source_lib.exists():
+                                        target_lib = target_dir / lib_name
+                                        if not target_lib.exists():
+                                            shutil.copy2(str(source_lib), str(target_lib))
+                                            # print(f"[TRITON FIX] Copied {lib_name} to: {target_lib}")
+                                        break
+                        
+        except Exception as e:
+            # print(f"[TRITON FIX] Warning: Could not copy libraries to Triton: {e}")
+            pass
+        
+    # print("[ENV CONFIG] Extended Triton compilation environment configured")
+
+def main():
+    """メイン処理"""
+    try:
+        # GUI起動前にstdout/stderrを復元（ログ出力のため）
+        try:
+            if hasattr(sys, '_original_stdout'):
+                sys.stdout = sys._original_stdout
+                sys.stderr = sys._original_stderr
+        except:
+            pass
+        
+        # コマンドライン引数をチェック
+        cache_only_mode = '--cache-only' in sys.argv
+        
+        # 実行ディレクトリ
+        if getattr(sys, 'frozen', False):
+            exe_dir = Path(sys.executable).parent
+        else:
+            exe_dir = Path(__file__).parent.parent
+        os.environ[APP_DIR_ENV] = str(exe_dir)
+        
+        # Tritonキャッシュクリアは削除（prebuild_cache.batで事前生成したキャッシュを活用）
+        # clear_triton_cache() は呼ばない
+        
+        # 埋め込みPython環境を設定
+        configure_embedded_environment(exe_dir)
+        
+        # 暗号化ファイル
+        core_dat = exe_dir / "runtime" / "core.dat"  # 統合暗号化ファイル
+        models_enc = exe_dir / "runtime" / "resources.dat"  # resources.datに修正
+        
+        # デバッグ用: スプラッシュウィンドウを無効化
+        # logger.info("起動中...")
+        
+        # 一時ディレクトリ
+        phase_start = _startup_phase_start()
+        temp_dir = tempfile.mkdtemp(prefix="automosa_")
+        _startup_log_phase(exe_dir, "temp", phase_start)
+        
+        try:
+            d = D()
+            
+            # 統合ファイル(core.dat)から復号化
+            # logger.info("初期化しています...")
+            
+            # core.datを読み込み
+            phase_start = _startup_phase_start()
+            with open(str(core_dat), 'rb') as f:
+                encrypted_unified_data = f.read()
+            _startup_log_phase(exe_dir, "core_read", phase_start)
+            
+            # 統合データを復号化
+            phase_start = _startup_phase_start()
+            decrypted_unified = d.f.decrypt(encrypted_unified_data)
+            unified_data = pickle.loads(decrypted_unified)
+            _startup_log_phase(exe_dir, "core_decrypt", phase_start)
+            
+            # ソース部分を復号化してファイル展開
+            phase_start = _startup_phase_start()
+            app_dir = os.path.join(temp_dir, "app")
+            source_encrypted = unified_data['sections']['source']
+            source_decrypted = d.f.decrypt(source_encrypted)
+            source_data = pickle.loads(source_decrypted)
+            
+            # ソースファイルを展開
+            for rel_path, content in source_data.items():
+                out_path = os.path.join(app_dir, rel_path)
+                os.makedirs(os.path.dirname(out_path), exist_ok=True)
+                with open(out_path, 'wb') as f:
+                    f.write(content)
+            _startup_log_phase(exe_dir, "source_unpack", phase_start)
+            
+            # モデル復号化（従来通り）
+            # logger.info("AI機能を準備中...")
+            models_dir = os.path.join(temp_dir, "models")
+            phase_start = _startup_phase_start()
+            with open(str(models_enc), 'rb') as f:
+                encrypted_models_data = f.read()
+            _startup_log_phase(exe_dir, "resources_read", phase_start)
+
+            phase_start = _startup_phase_start()
+            models_decrypted = d.f.decrypt(encrypted_models_data)
+            models_data = pickle.loads(models_decrypted)
+            _sam2_checkpoint_buffers.clear()
+            for rel_path, content in models_data.items():
+                if _register_sam2_checkpoint_buffer(rel_path, content):
+                    continue
+                out_path = os.path.join(models_dir, rel_path)
+                os.makedirs(os.path.dirname(out_path), exist_ok=True)
+                with open(out_path, 'wb') as f:
+                    f.write(content)
+            _startup_log_phase(exe_dir, "resources_unpack", phase_start)
+            
+            # パッケージ復号化（統合データからパッケージ部分を復号化）
+            # logger.info("パッケージを準備中...")
+            phase_start = _startup_phase_start()
+            packages_dir = os.path.join(temp_dir, "packages")
+            os.makedirs(packages_dir, exist_ok=True)
+            
+            # 統合データからパッケージ部分を取得
+            packages_encrypted = unified_data['sections']['packages']
+            packages_decrypted = d.f.decrypt(packages_encrypted)
+            packages_data = pickle.loads(packages_decrypted)
+            
+            # パッケージファイルを展開
+            for rel_path, content in packages_data.items():
+                out_path = os.path.join(packages_dir, rel_path)
+                os.makedirs(os.path.dirname(out_path), exist_ok=True)
+                with open(out_path, 'wb') as f:
+                    f.write(content)
+            _startup_log_phase(exe_dir, "packages_unpack", phase_start)
+
+            # 展開にだけ使うデータを、長寿命のアプリ実行フレームに残さない。
+            # SAM2用の重みは _sam2_checkpoint_buffers が必要な分だけ保持する。
+            del encrypted_unified_data, decrypted_unified, unified_data
+            del source_encrypted, source_decrypted, source_data
+            del encrypted_models_data, models_decrypted, models_data
+            del packages_encrypted, packages_decrypted, packages_data
+            content = None
+            
+            # 起動準備
+            # logger.info("起動準備中...")
+            
+            # Pythonパス設定（パッケージパスを最初に追加）
+            phase_start = _startup_phase_start()
+            sys.path.insert(0, packages_dir)
+            sys.path.insert(0, app_dir)
+            
+            # 環境変数設定
+            os.environ['AUTOMOSA_MODEL_DIR'] = models_dir
+            os.environ['AUTOMOSA_CONFIG_DIR'] = str(exe_dir / "config")  # configフォルダを設定ファイル保存場所に
+            os.environ['AUTOMOSA_MEMORY_MODELS'] = models_dir  # 暗号化環境判定用
+            os.environ[APP_DIR_ENV] = str(exe_dir)
+            if _sam2_checkpoint_buffers:
+                os.environ[SAM2_CHECKPOINT_PROVIDER_ENV] = (
+                    '__main__:get_sam2_checkpoint_bytes'
+                )
+                try:
+                    from video.sam2_checkpoint_locator import (
+                        set_sam2_checkpoint_bytes_provider,
+                    )
+                    set_sam2_checkpoint_bytes_provider(get_sam2_checkpoint_bytes)
+                except ImportError:
+                    pass
+            
+            # subprocess制御を適用（FLA/Tritonコンパイル時のコマンドプロンプトちらつき防止）
+            try:
+                from utils.subprocess_control import setup_comprehensive_process_suppression
+                setup_comprehensive_process_suppression()
+            except ImportError:
+                # subprocess制御が利用できない場合はスキップ
+                pass
+            _startup_log_phase(exe_dir, "path_setup", phase_start)
+            
+            # メイン起動
+            # logger.info("メインアプリケーション起動中...")
+            phase_start = _startup_phase_start()
+            import main
+            _startup_log_phase(exe_dir, "import_main", phase_start)
+            
+            # キャッシュ専用モードの場合は引数を調整
+            if cache_only_mode:
+                original_argv = sys.argv.copy()
+                sys.argv = [sys.argv[0], '--cache-only']
+                try:
+                    phase_start = _startup_phase_start()
+                    result = main.main()
+                    _startup_log_phase(exe_dir, "main_main", phase_start)
+                    # キャッシュ作成の結果に基づいて終了コードを設定
+                    sys.exit(0 if result else 1)
+                finally:
+                    sys.argv = original_argv
+            else:
+                phase_start = _startup_phase_start()
+                try:
+                    main.main()
+                finally:
+                    _startup_log_phase(exe_dir, "main_main", phase_start)
+            
+        finally:
+            # クリーンアップ
+            if os.path.exists(temp_dir):
+                try:
+                    shutil.rmtree(temp_dir, ignore_errors=True)
+                except:
+                    pass
+    
+    except Exception as e:
+        # 配布版では詳細なエラー情報を隠す
+        try:
+            from PySide6.QtWidgets import QApplication, QMessageBox
+            app = QApplication.instance()
+            if app is None:
+                app = QApplication([])
+            
+            error_msg = "アプリケーションの起動に失敗しました。\n\n"
+            error_msg += "以下を確認してください：\n"
+            error_msg += "・初回セットアップ.batを実行済みか\n"
+            error_msg += "・セキュリティソフトの除外設定\n"
+            error_msg += "・管理者権限での実行\n\n"
+            # error_msg += f"詳細なエラー情報は以下に保存されました：\n{log_file}"
+            
+            QMessageBox.critical(None, "起動エラー", error_msg)
+        except ImportError:
+            # PySide6が利用できない場合はtkinterを使用
+            import tkinter as tk
+            from tkinter import messagebox
+            
+            root = tk.Tk()
+            root.withdraw()
+            
+            error_msg = "アプリケーションの起動に失敗しました。\n\n"
+            error_msg += "以下を確認してくだ���い：\n"
+            error_msg += "・初回セットアップ.batを実行済みか\n"
+            error_msg += "・セキュリティソフトの除外設定\n"
+            error_msg += "・管理者権限での実行\n\n"
+            # error_msg += f"詳細なエラー情報は以下に保存されました：\n{log_file}"
+            
+            messagebox.showerror("起動エラー", error_msg)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()