refactor, script status now displaying

1 files changed, 78 insertions, 38 deletions

diff --git a/main.py b/main.py
index 5b60721..e2c4c3b 100644
--- a/main.py
+++ b/main.py
@@ -1,30 +1,42 @@
+import decky  # Old-style Decky import
 import os
 import subprocess
 import json
-import decky
+from pathlib import Path
 
 class Plugin:
+    async def _main(self):
+        decky.logger.info("Framegen plugin loaded (old decorator-free approach).")
+
+    async def _unload(self):
+        decky.logger.info("Framegen plugin unloaded.")
+
+    # Public method: front end can call this via callable("get_installed_games")
     async def get_installed_games(self) -> str:
         library_file = "/home/deck/.steam/steam/steamapps/libraryfolders.vdf"
         libraries = []
 
-        # Parse libraryfolders.vdf
+        # Find library folders
         if os.path.exists(library_file):
             with open(library_file, "r") as f:
                 lines = f.readlines()
                 for line in lines:
                     if '"path"' in line:
-                        path = line.split('"')[3]
-                        libraries.append(os.path.join(path, "steamapps"))
-        
-        # Fetch installed games from libraries
+                        folder_path = line.split('"')[3]
+                        libraries.append(os.path.join(folder_path, "steamapps"))
+
+        # Gather installed games
         games = []
         for library in libraries:
             if os.path.exists(library):
-                manifest_files = [f for f in os.listdir(library) if f.startswith("appmanifest_")]
+                manifest_files = [
+                    f for f in os.listdir(library)
+                    if f.startswith("appmanifest_")
+                ]
                 for manifest in manifest_files:
-                    with open(os.path.join(library, manifest), "r") as f:
-                        lines = f.readlines()
+                    manifest_path = os.path.join(library, manifest)
+                    with open(manifest_path, "r") as mf:
+                        lines = mf.readlines()
                         appid = ""
                         name = ""
                         for line in lines:
@@ -35,47 +47,75 @@ class Plugin:
                         if appid and name:
                             games.append({"appid": appid, "name": name})
 
-        # Return games as JSON string for compatibility with TSX
         return json.dumps(games)
 
-    @callable
+    # Public method: front end can call this via callable("run_install_fgmod")
     async def run_install_fgmod(self) -> dict:
         try:
-            # Define paths
             assets_dir = Path("/home/deck/homebrew/plugins/Decky-Framegen/assets")
             downloads_dir = Path.home() / "Downloads"
 
-            # Copy files to Downloads, overwriting if they exist
+            if not assets_dir.exists():
+                decky.logger.error(f"Assets directory not found: {assets_dir}")
+                return {
+                    "status": "error",
+                    "message": f"Assets directory not found: {assets_dir}"
+                }
+
+            downloads_dir.mkdir(parents=True, exist_ok=True)
+
             files_to_copy = ["prepare.sh", "fgmod.sh", "fgmod-uninstaller.sh"]
-            for file in files_to_copy:
-                src = assets_dir / file
-                dest = downloads_dir / file
-                if src.exists():
-                    dest.write_bytes(src.read_bytes())
-                    dest.chmod(0o755)  # Make the file executable
-                else:
-                    return {"status": "error", "message": f"{file} is missing in {assets_dir}"}
-
-            # Run prepare.sh
+            for file_name in files_to_copy:
+                src = assets_dir / file_name
+                if not src.exists():
+                    decky.logger.error(f"Required file missing: {src}")
+                    return {
+                        "status": "error",
+                        "message": f"Required file missing: {file_name}"
+                    }
+
+                dest = downloads_dir / file_name
+                dest.write_bytes(src.read_bytes())
+                dest.chmod(0o755)
+
             prepare_script = downloads_dir / "prepare.sh"
-            process = subprocess.run([str(prepare_script)], check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+            process = subprocess.run(
+                [str(prepare_script)],
+                capture_output=True,
+                text=True,
+                timeout=300
+            )
 
-            # Verify key files exist, if not create it
             fgmod_path = Path("/home/deck/fgmod")
-            if not fgmod_path.exists():
-                fgmod_path.mkdir(parents=True)
-                return {"status": "info", "message": "fgmod directory was not found and has been created"}
+            fgmod_path.mkdir(parents=True, exist_ok=True)
 
-            # Check for success message
             if "All done!" not in process.stdout:
-                return {"status": "error", "message": "Installation did not complete successfully"}
+                decky.logger.error("Installation did not complete successfully")
+                return {
+                    "status": "error",
+                    "message": "Installation did not complete successfully"
+                }
 
-            return {"status": "success", "output": process.stdout}
-        except subprocess.CalledProcessError as e:
-            return {"status": "error", "message": e.stderr}
+            return {
+                "status": "success",
+                "output": process.stdout
+            }
 
-    async def _main(self):
-        decky.logger.info("Plugin loaded.")
-
-    async def _unload(self):
-        decky.logger.info("Plugin unloaded.")
+        except subprocess.TimeoutExpired:
+            decky.logger.error("Installation script timed out")
+            return {
+                "status": "error",
+                "message": "Installation timed out"
+            }
+        except subprocess.CalledProcessError as e:
+            decky.logger.error(f"Script error: {e.stderr}")
+            return {
+                "status": "error",
+                "message": e.stderr
+            }
+        except Exception as e:
+            decky.logger.error(f"Unexpected error: {str(e)}")
+            return {
+                "status": "error",
+                "message": str(e)
+            }
\ No newline at end of file