multiple improvements

macOS support (untested)
made program automation-ready

Author: Cat-Ling

README.md

@@ -23,19 +23,39 @@ Download from the [releases page](https://github.com/Cat-Ling/unren) for your pl
 ## Usage
 
 ### Interactive Mode
+Run without arguments to launch the interactive menu:
 ```bash
-# From game's root directory
 ./unren-go
-
-# Or specify directory
-./unren-go --dir /path/to/game
 ```
 
-### Command Line
+If the game files aren't found, you'll see a **Recovery Menu** allowing you to browse directories interactively to locate the game.
+
+### Automation & CLI Mode
+Run with flags to perform actions immediately (no menu):
 ```bash
-./unren-go --no-menu    # Exit after single operation
+# Extract RPA and Decompile RPYC
+./unren-go -e -d /path/to/game
+
+# Perform ALL actions (Extract + Decompile + Apply all patches)
+./unren-go --all /path/to/game
+
+# Enable specific features
+./unren-go --console --skip /path/to/game
 ```
 
+### Options
+| Flag | Short | Description |
+|------|-------|-------------|
+| `--extract` | `-e` | Extract RPA packages |
+| `--decompile` | `-d` | Decompile RPYC files |
+| `--all` | `-a` | Perform all actions |
+| `--console` | | Enable Developer Console/Menu |
+| `--quicksave` | | Enable Quick Save/Load |
+| `--skip` | | Force enable skipping unseen content |
+| `--rollback` | | Force enable infinite rollback |
+| `--help` | `-h` | Show help and valid usages |
+| `--version` | `-v` | Show version info |
+
 ## License
 
 MIT License

detector/detector.go

@@ -1,6 +1,7 @@
 package detector
 
 import (
+	"fmt"
 	"os"
 	"path/filepath"
 	"strings"
@@ -10,6 +11,8 @@ import (
 
 // GameInfo contains detected information about a Ren'Py game
 type GameInfo struct {
+	// Name of the game (for display purposes)
+	Name string
 	// RootDir is the game's root directory (where the executable is)
 	RootDir string
 	// GameDir is the game's "game" subdirectory
@@ -22,6 +25,8 @@ type GameInfo struct {
 	RPYCFiles []string
 	// HasLib indicates if lib/ directory exists
 	HasLib bool
+	// LibDir is the path to the lib/ directory
+	LibDir string
 	// HasRenPy indicates if renpy/ directory exists
 	HasRenPy bool
 }
@@ -36,6 +41,16 @@ func DetectGame(dir string) (*GameInfo, error) {
 
 	info := &GameInfo{}
 
+	// Check for macOS App Bundle structure
+	// Standard Ren'Py Mac apps: MyApp.app/Contents/Resources/autorun/game
+	macAutorun := filepath.Join(absDir, "Contents", "Resources", "autorun")
+	if utils.DirExists(macAutorun) {
+		// Capture the .app name before switching context
+		info.Name = filepath.Base(absDir)
+		// Switch context to the autorun folder which acts as the game root
+		absDir = macAutorun
+	}
+
 	// Check if we're in the game/ subdirectory or the root
 	if filepath.Base(absDir) == "game" {
 		// We're in the game/ directory, parent is root
@@ -48,15 +63,34 @@ func DetectGame(dir string) (*GameInfo, error) {
 	} else {
 		// Try to find game/ in current directory
 		// Maybe we're in some other subdirectory
+		fmt.Printf("Detection: Failed to find game directory in %s\n", absDir)
 		return nil, &GameNotFoundError{Dir: absDir}
 	}
 
+	// If Name wasn't set by Mac detection, use the internal root dir name
+	if info.Name == "" {
+		info.Name = filepath.Base(info.RootDir)
+	}
+
 	// Check for lib/ and renpy/ directories
-	info.HasLib = utils.DirExists(filepath.Join(info.RootDir, "lib"))
+	libDir := filepath.Join(info.RootDir, "lib")
+	if utils.DirExists(libDir) {
+		info.HasLib = true
+		info.LibDir = libDir
+	} else {
+		// Fallback for macOS: lib/ might be in the parent directory (Contents/Resources/lib)
+		// while root is Contents/Resources/autorun
+		parentLib := filepath.Join(filepath.Dir(info.RootDir), "lib")
+		if utils.DirExists(parentLib) {
+			info.HasLib = true
+			info.LibDir = parentLib
+		}
+	}
+
 	info.HasRenPy = utils.DirExists(filepath.Join(info.RootDir, "renpy"))
 
 	// Detect Ren'Py version
-	info.RenPyVersion = detectRenPyVersion(info.RootDir)
+	info.RenPyVersion = detectRenPyVersion(info)
 
 	// Find RPA files
 	info.RPAFiles, _ = utils.FindFilesWithExtension(info.GameDir, ".rpa")
@@ -68,33 +102,28 @@ func DetectGame(dir string) (*GameInfo, error) {
 }
 
 // detectRenPyVersion attempts to detect the Ren'Py version
-func detectRenPyVersion(rootDir string) int {
+func detectRenPyVersion(info *GameInfo) int {
 	// Check for Python version indicators in lib/ directory
-	libDir := filepath.Join(rootDir, "lib")
-	if !utils.DirExists(libDir) {
-		return 0
-	}
-
-	// Walk lib directory looking for python version hints
-	entries, err := os.ReadDir(libDir)
-	if err != nil {
-		return 0
-	}
-
-	for _, entry := range entries {
-		name := strings.ToLower(entry.Name())
-		// Ren'Py 8 uses Python 3
-		if strings.Contains(name, "py3") || strings.Contains(name, "python3") {
-			return 8
-		}
-		// Ren'Py 7 and earlier use Python 2
-		if strings.Contains(name, "py2") || strings.Contains(name, "python2") {
-			return 7
+	if info.HasLib {
+		// Walk lib directory looking for python version hints
+		entries, err := os.ReadDir(info.LibDir)
+		if err == nil {
+			for _, entry := range entries {
+				name := strings.ToLower(entry.Name())
+				// Ren'Py 8 uses Python 3
+				if strings.Contains(name, "py3") || strings.Contains(name, "python3") {
+					return 8
+				}
+				// Ren'Py 7 and earlier use Python 2
+				if strings.Contains(name, "py2") || strings.Contains(name, "python2") {
+					return 7
+				}
+			}
 		}
 	}
 
 	// Check for specific version files
-	if utils.FileExists(filepath.Join(rootDir, "renpy", "__pycache__")) {
+	if utils.FileExists(filepath.Join(info.RootDir, "renpy", "__pycache__")) {
 		// __pycache__ indicates Python 3, so Ren'Py 8
 		return 8
 	}

files/python/rpatool.py

@@ -382,9 +382,12 @@ def save(self, filename = None):
         print('Could not open archive file {0} for reading: {1}'.format(archive, e), file=sys.stderr)
         sys.exit(1)
 
+    errors = 0
+
     if arguments.create or arguments.append:
         # We need this seperate function to recursively process directories.
         def add_file(filename):
+            nonlocal errors
             # If the archive path differs from the actual file path, as given in the argument,
             # extract the archive path and actual file path.
             if filename.find('=') != -1:
@@ -402,6 +405,7 @@ def add_file(filename):
                         archive.add(outfile, file.read())
                 except Exception as e:
                     print('Could not add file {0} to archive: {1}'.format(filename, e), file=sys.stderr)
+                    errors += 1
 
         # Iterate over the given files to add to archive.
         for filename in arguments.files:
@@ -413,20 +417,25 @@ def add_file(filename):
             archive.save(output)
         except Exception as e:
             print('Could not save archive file: {0}'.format(e), file=sys.stderr)
+            errors += 1
+
     elif arguments.delete:
         # Iterate over the given files to delete from the archive.
         for filename in arguments.files:
             try:
                 archive.remove(filename)
             except Exception as e:
                 print('Could not delete file {0} from archive: {1}'.format(filename, e), file=sys.stderr)
+                errors += 1
 
         # Set version for saving, and save.
         archive.version = version
         try:
             archive.save(output)
         except Exception as e:
             print('Could not save archive file: {0}'.format(e), file=sys.stderr)
+            errors += 1
+
     elif arguments.extract:
         # Either extract the given files, or all files if no files are given.
         if len(arguments.files) > 0:
@@ -456,6 +465,8 @@ def add_file(filename):
                     file.write(contents)
             except Exception as e:
                 print('Could not extract file {0} from archive: {1}'.format(filename, e), file=sys.stderr)
+                errors += 1
+
     elif arguments.list:
         # Print the sorted file list.
         list = archive.list()
@@ -466,3 +477,6 @@ def add_file(filename):
         print('No operation given :(')
         print('Use {0} --help for usage details.'.format(sys.argv[0]))
 
+    if errors > 0:
+        sys.exit(1)
+

files/python/rpatool_py2.py

@@ -358,12 +358,14 @@ def save(self, filename = None):
     # Normalize files.
     if len(arguments.files) > 0 and isinstance(arguments.files[0], list):
         arguments.files = arguments.files[0]
-
+    
     try:
         archive = RenPyArchive(archive, padlength=padding, key=key, version=version, verbose=arguments.verbose)
     except IOError as e:
         print('Could not open archive file {0} for reading: {1}'.format(archive, e), file=sys.stderr)
         sys.exit(1)
+    
+    errors = [0]
 
     if arguments.create or arguments.append:
         # We need this seperate function to recursively process directories.
@@ -385,6 +387,7 @@ def add_file(filename):
                         archive.add(outfile, file.read())
                 except Exception as e:
                     print('Could not add file {0} to archive: {1}'.format(filename, e), file=sys.stderr)
+                    errors[0] += 1
 
         # Iterate over the given files to add to archive.
         for filename in arguments.files:
@@ -396,20 +399,25 @@ def add_file(filename):
             archive.save(output)
         except Exception as e:
             print('Could not save archive file: {0}'.format(e), file=sys.stderr)
+            errors[0] += 1
+
     elif arguments.delete:
         # Iterate over the given files to delete from the archive.
         for filename in arguments.files:
             try:
                 archive.remove(filename)
             except Exception as e:
                 print('Could not delete file {0} from archive: {1}'.format(filename, e), file=sys.stderr)
+                errors[0] += 1
 
         # Set version for saving, and save.
         archive.version = version
         try:
             archive.save(output)
         except Exception as e:
             print('Could not save archive file: {0}'.format(e), file=sys.stderr)
+            errors[0] += 1
+
     elif arguments.extract:
         # Either extract the given files, or all files if no files are given.
         if len(arguments.files) > 0:
@@ -439,6 +447,8 @@ def add_file(filename):
                     file.write(contents)
             except Exception as e:
                 print('Could not extract file {0} from archive: {1}'.format(filename, e), file=sys.stderr)
+                errors[0] += 1
+
     elif arguments.list:
         # Print the sorted file list.
         list = archive.list()
@@ -449,3 +459,6 @@ def add_file(filename):
         print('No operation given :(')
         print('Use {0} --help for usage details.'.format(sys.argv[0]))
 
+    if errors[0] > 0:
+        sys.exit(1)
+

gem.md

@@ -0,0 +1,75 @@
+# Gems & Hacks
+
+This document outlines the specific workarounds and "hacky" solutions implemented in `unren-go` to support complex features like cross-platform macOS detection and robust automation piping.
+
+## 1. macOS `.app` Transparency (The Detector Hack)
+**Using macOS Game Files on Linux/Windows**
+
+Ren'Py games on macOS are packaged as `.app` bundles, which are directories. The actual game assets (RPYC/RPA) live deep inside at `Contents/Resources/autorun/`.
+To make this transparent to the user (so they can just point at `Game.app`), we implemented a path redirection hack in `detector/detector.go`.
+
+**Location:** `detector/detector.go` -> `DetectGame`
+**The Hack:**
+```go
+// Check for macOS App Bundle structure
+if strings.HasSuffix(absDir, ".app") || strings.Contains(absDir, ".app/") {
+    // ...
+    macAutorun := filepath.Join(absDir, "Contents", "Resources", "autorun")
+    if utils.DirExists(macAutorun) {
+        // Switch context to the autorun folder which acts as the game root
+        absDir = macAutorun
+    }
+}
+```
+We aggressively rewrite the `absDir` variable if we suspect a macOS bundle. This allows the rest of the detection logic (checking for `game/`) to work unchanged.
+
+## 2. OS-Agnostic Python Detection
+**Finding Mac Binaries on Linux**
+
+Normally, `runner.go` should verify the OS (`runtime.GOOS`) before deciding where to look for the Python interpreter. However, to support analyzing macOS games on Linux (detecting version, etc.), we removed the OS guard.
+
+**Location:** `runner/runner.go` -> `findPython`
+**The Hack:**
+```go
+// Check for macOS App Bundle structure (Check unconditionally to support cross-OS inspection)
+macExePath := filepath.Join(filepath.Dir(filepath.Dir(libDir)), "MacOS", "python")
+if _, err := os.Stat(macExePath); err == nil {
+    return macExePath, libDir, true, nil
+}
+```
+We check for the Mac binary *unconditionally*. While we can't *execute* this binary on Linux/Windows, detecting it allows the `GameInfo` struct to be populated correctly, letting the tool report the Ren'Py version and file counts even if it can't run the decompression.
+
+## 3. Pipeline State Mutation
+**The `-e -d` Pipeline Fix**
+
+When running `unren-go -e -d`, the tool extracts RPAs and then immediately tries to decompile RPYCs. The problem is that the `game` struct is populated *before* extraction, so the decompiler doesn't know about the files that were just created.
+
+**Location:** `main.go` -> `handleExtractRPA`
+**The Hack:**
+```go
+// Refresh RPYC file list in case new files were extracted
+// This ensures that if decompilation runs after this, it sees the new files
+if found, err := utils.FindFilesWithExtension(game.GameDir, ".rpyc"); err == nil {
+    game.RPYCFiles = found
+}
+```
+We actively mutate the `game.RPYCFiles` slice inside the extraction polling function. This couples the detection state with the extraction action, but it's the most efficient way to ensure the pipeline proceeds without a full re-detection loop.
+
+## 4. Vendor Script Patching
+**Fixing `rpatool.py` Exit Codes**
+
+The original `rpatool` library returns exit code `0` (Success) even if it encounters errors during batch extraction. This made implementing the `--clean` flag dangerous, as we rely on exit codes to know if it's safe to delete source files.
+
+**Location:** `files/python/rpatool.py` (and `rpatool_py2.py`)
+**The Hack:**
+We injected error tracking logic into the upstream script:
+```python
+errors = 0
+# ... inside loops ...
+except Exception as e:
+    errors += 1
+# ... at end of file ...
+if errors > 0:
+    sys.exit(1)
+```
+Instead of wrapping the python execution in complex stderr parsing (which is brittle), we patched the "vendor" code directly to behave like a standard CLI tool. This ensures `unren-go` receives a clear signal (`exit status 1`) if *anything* goes wrong, protecting user data.