mcp-server-if 0.1.0__py3-none-macosx_13_0_arm64.whl → 0.2.0__py3-none-macosx_13_0_arm64.whl

mcp_server_if/config.py

@@ -13,20 +13,20 @@ def get_games_dir() -> Path:
     return Path.home() / ".mcp-server-if" / "games"
 
 
-def get_bundled_glulxe() -> Path | None:
-    """Get the bundled glulxe binary path if it exists."""
+def _get_bundled_binary(name: str) -> Path | None:
+    """Get a bundled binary path if it exists."""
     package_dir = Path(__file__).parent
-    for name in ("glulxe", "glulxe.exe"):
-        bundled = package_dir / "bin" / name
+    for suffix in (name, f"{name}.exe"):
+        bundled = package_dir / "bin" / suffix
         if bundled.exists() and bundled.is_file():
             return bundled
     return None
 
 
-def get_glulxe_path() -> Path | None:
-    """Get the glulxe binary path from environment, bundled, or auto-detect."""
+def _find_binary(name: str, env_var: str) -> Path | None:
+    """Find a binary from env var, bundled, PATH, or common locations."""
     # 1. Check environment variable
-    env_path = os.environ.get("IF_GLULXE_PATH")
+    env_path = os.environ.get(env_var)
     if env_path:
         path = Path(env_path)
         if path.exists() and path.is_file():
@@ -34,20 +34,20 @@ def get_glulxe_path() -> Path | None:
         return None
 
     # 2. Check for bundled binary (installed with package)
-    bundled = get_bundled_glulxe()
+    bundled = _get_bundled_binary(name)
     if bundled:
         return bundled
 
-    # 3. Try to find glulxe in PATH
-    glulxe_in_path = shutil.which("glulxe")
-    if glulxe_in_path:
-        return Path(glulxe_in_path)
+    # 3. Try to find in PATH
+    in_path = shutil.which(name)
+    if in_path:
+        return Path(in_path)
 
     # 4. Check common locations
     common_paths = [
-        Path.home() / ".local" / "bin" / "glulxe",
-        Path("/usr/local/bin/glulxe"),
-        Path("/usr/bin/glulxe"),
+        Path.home() / ".local" / "bin" / name,
+        Path("/usr/local/bin") / name,
+        Path("/usr/bin") / name,
     ]
 
     for path in common_paths:
@@ -57,6 +57,27 @@ def get_glulxe_path() -> Path | None:
     return None
 
 
+# Keep public API for backwards compatibility
+def get_bundled_glulxe() -> Path | None:
+    """Get the bundled glulxe binary path if it exists."""
+    return _get_bundled_binary("glulxe")
+
+
+def get_glulxe_path() -> Path | None:
+    """Get the glulxe binary path from environment, bundled, or auto-detect."""
+    return _find_binary("glulxe", "IF_GLULXE_PATH")
+
+
+def get_bundled_bocfel() -> Path | None:
+    """Get the bundled bocfel binary path if it exists."""
+    return _get_bundled_binary("bocfel")
+
+
+def get_bocfel_path() -> Path | None:
+    """Get the bocfel binary path from environment, bundled, or auto-detect."""
+    return _find_binary("bocfel", "IF_BOCFEL_PATH")
+
+
 def _get_require_journal() -> bool:
     """Check if journal mode is enabled."""
     return os.environ.get("IF_REQUIRE_JOURNAL", "").lower() in ("1", "true", "yes")
@@ -69,10 +90,12 @@ class Config:
         self,
         games_dir: Path | None = None,
         glulxe_path: Path | None = None,
+        bocfel_path: Path | None = None,
         require_journal: bool | None = None,
     ):
         self.games_dir = games_dir or get_games_dir()
         self.glulxe_path: Path | None = glulxe_path or get_glulxe_path()
+        self.bocfel_path: Path | None = bocfel_path or get_bocfel_path()
         self._require_journal = require_journal if require_journal is not None else _get_require_journal()
 
     @property
@@ -84,20 +107,27 @@ class Config:
         self.games_dir.mkdir(parents=True, exist_ok=True)
 
     def validate(self) -> list[str]:
-        """Validate configuration. Returns list of errors."""
+        """Validate glulxe configuration. Returns list of errors."""
+        return self._validate_binary("glulxe", self.glulxe_path)
+
+    def validate_bocfel(self) -> list[str]:
+        """Validate bocfel configuration. Returns list of errors."""
+        return self._validate_binary("bocfel", self.bocfel_path)
+
+    def _validate_binary(self, name: str, path: Path | None) -> list[str]:
         errors = []
-        if not self.glulxe_path:
+        if not path:
             checked = [
-                "IF_GLULXE_PATH env var",
+                f"IF_{name.upper()}_PATH env var",
                 f"bundled binary at {Path(__file__).parent / 'bin'}",
-                "glulxe in PATH",
+                f"{name} in PATH",
             ]
             errors.append(
-                "glulxe binary not found. Checked:\n"
+                f"{name} binary not found. Checked:\n"
                 + "\n".join(f"  - {loc}" for loc in checked)
                 + "\n\nFor development: run 'uv sync --reinstall-package mcp-server-if' to compile from source."
                 + "\nFor production: install the wheel from PyPI."
             )
-        elif not self.glulxe_path.exists():
-            errors.append(f"glulxe binary not found at: {self.glulxe_path}")
+        elif not path.exists():
+            errors.append(f"{name} binary not found at: {path}")
         return errors

mcp_server_if/server.py

@@ -14,7 +14,7 @@ import httpx
 from mcp.server.fastmcp import FastMCP
 
 from .config import Config
-from .session import GlulxSession, detect_game_format, find_game_file
+from .session import GlulxSession, detect_game_format, find_game_file, is_zcode_format
 
 
 class JournalEntry(TypedDict):
@@ -25,8 +25,9 @@ class JournalEntry(TypedDict):
     reflection: str
 
 
-# IF Archive base URL
-IF_ARCHIVE_BASE = "https://ifarchive.org/if-archive/games/glulx"
+# IF Archive base URLs
+IF_ARCHIVE_GLULX = "https://ifarchive.org/if-archive/games/glulx"
+IF_ARCHIVE_ZCODE = "https://ifarchive.org/if-archive/games/zcode"
 
 # Global config - set at startup
 _config: Config | None = None
@@ -114,6 +115,15 @@ def _list_available_games() -> list[str]:
     return sorted(games)
 
 
+def _make_session(game_dir: Path) -> GlulxSession:
+    """Create a session with the correct interpreter for the game format."""
+    config = get_config()
+    game_file = find_game_file(game_dir)
+    if game_file and is_zcode_format(game_file.suffix.lstrip(".")):
+        return GlulxSession(game_dir, interpreter_path=config.bocfel_path)
+    return GlulxSession(game_dir, glulxe_path=config.glulxe_path)
+
+
 @mcp.tool()
 async def play_if(game: str, command: str = "", journal: str = "") -> str:
     """Play a turn of interactive fiction.
@@ -130,14 +140,9 @@ async def play_if(game: str, command: str = "", journal: str = "") -> str:
     if not game:
         return "Error: game name required"
 
-    # Validate glulxe
-    errors = config.validate()
-    if errors:
-        return "Error: " + "; ".join(errors)
-    assert config.glulxe_path is not None
-
     game_dir = _get_game_dir(game)
-    if not find_game_file(game_dir):
+    game_file = find_game_file(game_dir)
+    if not game_file:
         available = _list_available_games()
         msg = f"Game '{game}' not found."
         if available:
@@ -145,7 +150,18 @@ async def play_if(game: str, command: str = "", journal: str = "") -> str:
         msg += "\nUse download_game to get new games."
         return msg
 
-    session = GlulxSession(game_dir, config.glulxe_path)
+    # Validate the appropriate interpreter
+    ext = game_file.suffix.lstrip(".")
+    if is_zcode_format(ext):
+        errors = config.validate_bocfel()
+        if errors:
+            return "Error: " + "; ".join(errors)
+    else:
+        errors = config.validate()
+        if errors:
+            return "Error: " + "; ".join(errors)
+
+    session = _make_session(game_dir)
 
     # Warn about save/restore commands
     if command.strip().lower() in ("save", "restore"):
@@ -220,10 +236,9 @@ async def list_games() -> str:
         )
 
     lines = ["**Available games:**", ""]
-    config = get_config()
     for game in games:
         game_dir = _get_game_dir(game)
-        session = GlulxSession(game_dir, config.glulxe_path)
+        session = _make_session(game_dir)
         status = "has saved state" if session.has_state() else "no saved state"
         lines.append(f"- {game} ({status})")
 
@@ -251,9 +266,10 @@ async def download_game(name: str, url: str) -> str:
     if not url:
         return "Error: url required (full URL or IF Archive filename like 'advent.ulx')"
 
-    # If URL is just a filename, construct IF Archive URL
+    # If URL is just a filename, try to route to the right IF Archive path
     if not url.startswith("http"):
-        url = f"{IF_ARCHIVE_BASE}/{url}"
+        ext = url.rsplit(".", 1)[-1].lower() if "." in url else ""
+        url = f"{IF_ARCHIVE_ZCODE}/{url}" if is_zcode_format(ext) else f"{IF_ARCHIVE_GLULX}/{url}"
 
     game_dir = _get_game_dir(name)
 
@@ -268,7 +284,7 @@ async def download_game(name: str, url: str) -> str:
 
         game_format = detect_game_format(content)
         if not game_format:
-            return f"Error: Downloaded file is not a valid Glulx or Blorb game (magic bytes: {content[:12]!r})"
+            return f"Error: Downloaded file is not a valid game (magic bytes: {content[:12]!r})"
 
         game_file = game_dir / f"game.{game_format}"
         game_file.write_bytes(content)
@@ -289,7 +305,6 @@ async def reset_game(game: str) -> str:
     Args:
         game: Name of the game to reset
     """
-    config = get_config()
     game = game.strip()
 
     if not game:
@@ -299,7 +314,7 @@ async def reset_game(game: str) -> str:
     if not find_game_file(game_dir):
         return f"Game '{game}' not found."
 
-    session = GlulxSession(game_dir, config.glulxe_path)
+    session = _make_session(game_dir)
     session.clear_state()
 
     return f"Game '{game}' reset. Journal preserved. Use play_if to start fresh."
@@ -382,6 +397,11 @@ def main():
         type=Path,
         help="Path to glulxe binary (default: auto-detect or IF_GLULXE_PATH)",
     )
+    parser.add_argument(
+        "--bocfel-path",
+        type=Path,
+        help="Path to bocfel binary (default: auto-detect or IF_BOCFEL_PATH)",
+    )
     parser.add_argument(
         "--require-journal",
         action="store_true",
@@ -395,6 +415,7 @@ def main():
     _config = Config(
         games_dir=args.games_dir,
         glulxe_path=args.glulxe_path,
+        bocfel_path=args.bocfel_path,
         require_journal=args.require_journal,
     )
 

mcp_server_if/session.py

@@ -1,47 +1,121 @@
-"""Glulx game session management with RemGlk protocol."""
+"""Game session management with RemGlk protocol."""
 
 from __future__ import annotations
 
 import asyncio
 import json
+import os
 from pathlib import Path
 
 # Magic bytes for game formats
 GLULX_MAGIC = b"Glul"  # Glulx game file
 BLORB_MAGIC = b"FORM"  # Blorb container (FORM....IFRS)
 
+# Z-code versions (byte 0 of the file)
+ZCODE_VERSIONS = range(1, 9)  # 1-8
+
+# File extensions by format family
+GLULX_EXTENSIONS = ("ulx", "gblorb")
+ZCODE_EXTENSIONS = ("z3", "z4", "z5", "z7", "z8", "zblorb")
+ALL_GAME_EXTENSIONS = GLULX_EXTENSIONS + ZCODE_EXTENSIONS
+
 
 def detect_game_format(content: bytes) -> str | None:
-    """Detect game format from magic bytes. Returns 'ulx', 'gblorb', or None."""
+    """Detect game format from magic bytes.
+
+    Returns 'ulx', 'gblorb', 'zblorb', 'z3', 'z5', 'z8', etc., or None.
+    """
     if content.startswith(GLULX_MAGIC):
         return "ulx"
+
     if content.startswith(BLORB_MAGIC) and len(content) > 12 and content[8:12] == b"IFRS":
-        return "gblorb"
+        # Blorb container — scan for exec chunk to disambiguate
+        return _detect_blorb_type(content)
+
+    # Z-code: byte 0 is version (1-8), check for valid serial number at bytes 18-23
+    if len(content) >= 64 and content[0] in ZCODE_VERSIONS:
+        serial = content[18:24]
+        if all(0x20 <= b <= 0x7E for b in serial):
+            return f"z{content[0]}"
+
     return None
 
 
+def _detect_blorb_type(content: bytes) -> str:
+    """Scan a Blorb IFF to find exec resource type (ZCOD or GLUL)."""
+    pos = 12  # skip FORM + size + IFRS
+    while pos + 8 <= len(content):
+        chunk_type = content[pos : pos + 4]
+        chunk_size = int.from_bytes(content[pos + 4 : pos + 8], "big")
+
+        if chunk_type == b"RIdx":
+            # Resource index — scan entries for Exec resources
+            if pos + 12 <= len(content):
+                num_entries = int.from_bytes(content[pos + 8 : pos + 12], "big")
+                entry_pos = pos + 12
+                for _ in range(num_entries):
+                    if entry_pos + 12 > len(content):
+                        break
+                    usage = content[entry_pos : entry_pos + 4]
+                    if usage == b"Exec":
+                        # The entry points to a chunk; find that chunk's type
+                        chunk_offset = int.from_bytes(content[entry_pos + 8 : entry_pos + 12], "big")
+                        if chunk_offset + 4 <= len(content):
+                            exec_type = content[chunk_offset : chunk_offset + 4]
+                            if exec_type == b"ZCOD":
+                                return "zblorb"
+                            elif exec_type == b"GLUL":
+                                return "gblorb"
+                    entry_pos += 12
+            break
+
+        # Advance to next chunk (chunks are 2-byte aligned)
+        pos += 8 + chunk_size
+        if chunk_size % 2:
+            pos += 1
+
+    # Default to gblorb if we can't determine
+    return "gblorb"
+
+
 def find_game_file(game_dir: Path) -> Path | None:
-    """Find the game file in a game directory (.ulx or .gblorb)."""
-    for ext in ("ulx", "gblorb"):
+    """Find the game file in a game directory."""
+    for ext in ALL_GAME_EXTENSIONS:
         game_file = game_dir / f"game.{ext}"
         if game_file.exists():
             return game_file
     return None
 
 
+def is_zcode_format(ext: str) -> bool:
+    """Check if a file extension is a Z-code format."""
+    return ext in ZCODE_EXTENSIONS
+
+
 class GlulxSession:
-    """Manages a glulxe session with RemGlk JSON protocol."""
+    """Manages a game session with RemGlk JSON protocol."""
 
-    def __init__(self, game_dir: Path, glulxe_path: Path | None = None):
+    def __init__(self, game_dir: Path, glulxe_path: Path | None = None, interpreter_path: Path | None = None):
         self.game_dir = game_dir
         self.glulxe_path = glulxe_path
+        self.interpreter_path = interpreter_path or glulxe_path
         self.game_file = find_game_file(game_dir)
         self.state_dir = game_dir / "state"
         self.metadata_file = game_dir / "metadata.json"
 
+    @property
+    def _is_zcode(self) -> bool:
+        """Check if current game is Z-code format."""
+        if self.game_file is None:
+            return False
+        return is_zcode_format(self.game_file.suffix.lstrip("."))
+
     def has_state(self) -> bool:
         """Check if saved state exists."""
-        return (self.state_dir / "autosave.json").exists()
+        if not self.state_dir.exists():
+            return False
+        # glulxe uses autosave.json; bocfel uses {checksum}.json
+        return any(f.suffix == ".json" for f in self.state_dir.iterdir())
 
     def load_metadata(self) -> dict:
         """Load session metadata."""
@@ -77,10 +151,10 @@ class GlulxSession:
         if not self.game_file or not self.game_file.exists():
             raise FileNotFoundError(f"Game file not found in: {self.game_dir}")
 
-        if not self.glulxe_path or not self.glulxe_path.exists():
+        if not self.interpreter_path or not self.interpreter_path.exists():
             raise FileNotFoundError(
-                f"glulxe binary not found: {self.glulxe_path}\n"
-                "Set IF_GLULXE_PATH or see README.md for build instructions."
+                f"Interpreter binary not found: {self.interpreter_path}\n"
+                "Run 'uv sync --reinstall-package mcp-server-if' to compile from source."
             )
 
         # Ensure state directory exists
@@ -89,20 +163,11 @@ class GlulxSession:
         # Load metadata
         metadata = self.load_metadata()
 
-        # Build glulxe command
-        cmd = [
-            str(self.glulxe_path),
-            "-singleturn",
-            "-fm",
-            "--autosave",
-            "--autodir",
-            str(self.state_dir),
-        ]
-
-        if self.has_state():
-            cmd.append("--autorestore")
-
-        cmd.append(str(self.game_file))
+        # Build command and environment
+        if self._is_zcode:
+            cmd, env = self._build_bocfel_cmd()
+        else:
+            cmd, env = self._build_glulxe_cmd()
 
         # Build input JSON
         if command is None or not self.has_state():
@@ -118,9 +183,6 @@ class GlulxSession:
 
             if input_type == "char":
                 # Character input - send single char or RemGlk special key name.
-                # RemGlk special keys: return, escape, tab, left, right, up, down,
-                # pageup, pagedown, home, end, func1-func12.
-                # Regular chars (including space) are sent as literal single chars.
                 if not command:
                     key = " "
                 elif command in ("\n", "\r") or command.strip().lower() in ("enter", "return"):
@@ -134,12 +196,14 @@ class GlulxSession:
                 # Line input
                 input_json = {"type": "line", "gen": metadata["gen"], "window": input_window, "value": command}
 
-        # Run glulxe
+        # Run interpreter
         proc = await asyncio.create_subprocess_exec(
             *cmd,
             stdin=asyncio.subprocess.PIPE,
             stdout=asyncio.subprocess.PIPE,
             stderr=asyncio.subprocess.PIPE,
+            cwd=self.game_dir,
+            env=env,
         )
 
         input_bytes = (json.dumps(input_json) + "\n").encode()
@@ -148,20 +212,20 @@ class GlulxSession:
         if proc.returncode != 0:
             error = stderr.decode("utf-8", errors="replace").strip()
             stdout_preview = stdout.decode("utf-8", errors="replace")[:500]
-            raise RuntimeError(f"glulxe failed (exit {proc.returncode}): {error}\nstdout: {stdout_preview}")
+            raise RuntimeError(f"Interpreter failed (exit {proc.returncode}): {error}\nstdout: {stdout_preview}")
 
         # Parse output - RemGlk sends JSON terminated by blank line
         output_text = stdout.decode("utf-8", errors="replace")
         output_lines = output_text.strip().split("\n\n")
 
         if not output_lines:
-            raise RuntimeError("No output from glulxe")
+            raise RuntimeError("No output from interpreter")
 
         # Parse the JSON output
         try:
             output = json.loads(output_lines[0])
         except json.JSONDecodeError as e:
-            raise RuntimeError(f"Failed to parse glulxe output: {e}\nOutput: {output_text[:500]}") from e
+            raise RuntimeError(f"Failed to parse interpreter output: {e}\nOutput: {output_text[:500]}") from e
 
         # Update metadata from output
         if "gen" in output:
@@ -194,6 +258,35 @@ class GlulxSession:
 
         return formatted, metadata
 
+    def _build_glulxe_cmd(self) -> tuple[list[str], dict[str, str] | None]:
+        """Build command for glulxe interpreter."""
+        cmd = [
+            str(self.interpreter_path),
+            "-singleturn",
+            "-fm",
+            "--autosave",
+            "--autodir",
+            str(self.state_dir),
+        ]
+        if self.has_state():
+            cmd.append("--autorestore")
+        cmd.append(str(self.game_file))
+        return cmd, None
+
+    def _build_bocfel_cmd(self) -> tuple[list[str], dict[str, str]]:
+        """Build command and environment for bocfel interpreter."""
+        cmd = [
+            str(self.interpreter_path),
+            "-singleturn",
+            "-fm",
+            "-H",  # Disable history playback (unnecessary with AutosaveLib)
+            str(self.game_file),
+        ]
+        # Bocfel reads autosave config from environment variables
+        env = os.environ.copy()
+        env["BOCFEL_AUTOSAVE_DIRECTORY"] = str(self.state_dir)
+        return cmd, env
+
     def _format_output(self, output: dict, windows: list) -> str:
         """Format RemGlk output as readable text."""
         result = []

{mcp_server_if-0.1.0.dist-info → mcp_server_if-0.2.0.dist-info}/METADATA

@@ -1,14 +1,14 @@
 Metadata-Version: 2.4
 Name: mcp-server-if
-Version: 0.1.0
-Summary: MCP server for playing Glulx interactive fiction games
+Version: 0.2.0
+Summary: MCP server for playing interactive fiction games (Glulx and Z-machine)
 Project-URL: Homepage, https://github.com/davidar/mcp-server-if
 Project-URL: Repository, https://github.com/davidar/mcp-server-if
 Project-URL: Issues, https://github.com/davidar/mcp-server-if/issues
 Author-email: David A Roberts <d@vidr.cc>
 License-Expression: MIT
 License-File: LICENSE
-Keywords: claude,glulx,interactive-fiction,mcp,text-adventure
+Keywords: claude,glulx,interactive-fiction,mcp,text-adventure,z-machine,zcode
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
@@ -25,16 +25,16 @@ Description-Content-Type: text/markdown
 
 # mcp-server-if
 
-An MCP (Model Context Protocol) server for playing Glulx interactive fiction games. Enables AI assistants like Claude to play text adventure games through a standardized interface.
+An MCP (Model Context Protocol) server for playing interactive fiction games. Enables AI assistants like Claude to play text adventure games through a standardized interface.
 
 ## Features
 
-- Play Glulx (.ulx) and Blorb (.gblorb) interactive fiction games
+- Play Glulx (.ulx, .gblorb) and Z-machine (.z3-.z8, .zblorb) games
 - Automatic game state persistence (save/restore between sessions)
 - Download games directly from the IF Archive
 - Optional journaling mode for reflective playthroughs
 - Works with Claude Desktop, Claude Code, and other MCP clients
-- Bundled glulxe interpreter (no manual compilation required)
+- Bundled interpreters (glulxe for Glulx, bocfel for Z-machine)
 
 ## Installation
 
@@ -46,7 +46,7 @@ uvx mcp-server-if
 pip install mcp-server-if
 ```
 
-The package includes a pre-compiled `glulxe` binary. No additional setup required.
+The package includes pre-compiled interpreters. No additional setup required.
 
 ## Configuration
 
@@ -56,6 +56,7 @@ The package includes a pre-compiled `glulxe` binary. No additional setup require
 |----------|-------------|---------|
 | `IF_GAMES_DIR` | Directory to store games | `~/.mcp-server-if/games` |
 | `IF_GLULXE_PATH` | Override path to glulxe binary | Bundled binary |
+| `IF_BOCFEL_PATH` | Override path to bocfel binary | Bundled binary |
 | `IF_REQUIRE_JOURNAL` | Require journal reflections | `false` |
 
 ### Command Line Arguments
@@ -130,10 +131,15 @@ search_journal(game="zork", query="treasure")
 
 ## Supported Game Formats
 
+**Glulx** (modern, uses glulxe interpreter):
 - `.ulx` - Raw Glulx game files
-- `.gblorb` - Blorb containers with Glulx games (may include graphics/sound)
+- `.gblorb` - Blorb containers with Glulx games
 
-Find games at the [IF Archive](https://ifarchive.org/indexes/if-archive/games/glulx/).
+**Z-machine** (classic Infocom format, uses bocfel interpreter):
+- `.z3`, `.z4`, `.z5`, `.z7`, `.z8` - Z-code game files
+- `.zblorb` - Blorb containers with Z-machine games
+
+Find games at the IF Archive: [Glulx games](https://ifarchive.org/indexes/if-archive/games/glulx/), [Z-code games](https://ifarchive.org/indexes/if-archive/games/zcode/).
 
 ## Journaling Mode
 
@@ -150,34 +156,36 @@ This encourages thoughtful, reflective gameplay rather than rushing through.
 
 1. Games are stored in `~/.mcp-server-if/games/{name}/`
 2. Each game directory contains:
-   - `game.ulx` or `game.gblorb` - the game file
+   - The game file (`.ulx`, `.gblorb`, `.z5`, etc.)
    - `state/` - autosave data (persists between sessions)
    - `metadata.json` - session metadata
    - `journal.jsonl` - playthrough journal (if enabled)
 
-3. The server uses glulxe's RemGlk mode for JSON-based I/O
-4. Game state is automatically saved after each turn
-
-## Building from Source
+3. The server selects the appropriate interpreter based on file format:
+   - Glulx games → glulxe
+   - Z-machine games → bocfel
+4. Both interpreters use RemGlk for JSON-based I/O
+5. Game state is automatically saved after each turn
 
-If installing from source (not from PyPI), glulxe will be compiled during installation. This requires:
+## Development
 
-- C compiler (gcc or clang)
-- make
-- git (for submodules)
+Requires [uv](https://docs.astral.sh/uv/), a C compiler (gcc or clang), a C++ compiler (g++ or clang++), make, and git.
 
 ```bash
 git clone --recursive https://github.com/davidar/mcp-server-if.git
 cd mcp-server-if
-pip install .
+uv sync --group dev
+uv run pytest -v
 ```
 
+`uv sync` compiles the bundled interpreters (glulxe and bocfel) from source automatically. If binaries are missing after a fresh clone, run `uv sync --reinstall-package mcp-server-if` to force recompilation.
+
 ## Troubleshooting
 
 ### "glulxe binary not found"
 
 This shouldn't happen with pip/uvx installs. If it does:
-- Try reinstalling: `pip install --force-reinstall mcp-server-if`
+- Try reinstalling: `pip install --force-reinstall mcp-server-if` or `uv sync --reinstall-package mcp-server-if`
 - Or set `IF_GLULXE_PATH` to a manually installed glulxe
 
 ### "Game file not found"
@@ -195,5 +203,6 @@ MIT License - see [LICENSE](LICENSE) for details.
 ## Credits
 
 - [glulxe](https://github.com/erkyrath/glulxe) - The Glulx VM interpreter by Andrew Plotkin
+- [bocfel](https://github.com/garglk/garglk/tree/master/terps/bocfel) - Z-machine interpreter by Chris Spiegel
 - [RemGlk](https://github.com/erkyrath/remglk) - Remote Glk library for JSON I/O
 - [MCP](https://modelcontextprotocol.io/) - Model Context Protocol by Anthropic

mcp_server_if-0.2.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+mcp_server_if/server.py,sha256=JmdIeiAVdGLDA1KfXIDo5hhwplS7A7Znw6KkAwH8L2k,13006
+mcp_server_if/config.py,sha256=1eu-4zTnXaSv3kAhwoM-xWiirDnuApiY4qGcIfR4bhM,4307
+mcp_server_if/session.py,sha256=1NhQZu0jIxXSTsl7Wv10-r2f67k0UxAljnCdgqHwZbI,14229
+mcp_server_if/__init__.py,sha256=9CHcB-6L566M9Gy_R5tzYWp8gXK1GJ5DhINUiJKK28Y,289
+mcp_server_if/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mcp_server_if/__main__.py,sha256=HEiagMZ-9v0Ugdszyh4nC7R-esMTX8Bk7vu3ox3McLI,132
+mcp_server_if/bin/bocfel,sha256=E9Rjj8TrxxC5Ce_CDqHjF0iNnnaMtzxHUqhxJ63zrbQ,954008
+mcp_server_if/bin/glulxe,sha256=uldM0whGQ8-Yb0_rzoRW4QT66Sit5jbn3xcYkQABlHc,511784
+mcp_server_if-0.2.0.dist-info/RECORD,,
+mcp_server_if-0.2.0.dist-info/WHEEL,sha256=hjZsBS66YMok_dT7wQSTJC0OsKhPojW1tCbjA-hXXlg,102
+mcp_server_if-0.2.0.dist-info/entry_points.txt,sha256=Fh-zkWrbgDBe_2UzNjRKYR6vw_kc-q5GnIojwdFS3vk,53
+mcp_server_if-0.2.0.dist-info/METADATA,sha256=IvnQjR5aDcHRx7vclAtIoBWDnSzYA4OoU-aYZ3nc5YE,6697
+mcp_server_if-0.2.0.dist-info/licenses/LICENSE,sha256=BXxcwr8hEiK-byLXh_amNTuuES4DlNmCmLmQMlVptNY,1072

mcp_server_if-0.1.0.dist-info/RECORD

@@ -1,12 +0,0 @@
-mcp_server_if/server.py,sha256=lYuWCCmseoRpkiP4zCnd9lk-wZy6AhadfgmMq9Ly2-o,12100
-mcp_server_if/config.py,sha256=MXDDzHPv6vhTEAj9x_Zqn4Ys4rfl_LDNgVfRD0wc1Y4,3239
-mcp_server_if/session.py,sha256=VXamjN85XezxfCuhmfoBO82t78q9YPD_JEWw7vSIHcE,10663
-mcp_server_if/__init__.py,sha256=9CHcB-6L566M9Gy_R5tzYWp8gXK1GJ5DhINUiJKK28Y,289
-mcp_server_if/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mcp_server_if/__main__.py,sha256=HEiagMZ-9v0Ugdszyh4nC7R-esMTX8Bk7vu3ox3McLI,132
-mcp_server_if/bin/glulxe,sha256=ePqNih0EGXXCu1ah9IQRAq-QRw2Ab4_7tMy1hKb4Tk8,511784
-mcp_server_if-0.1.0.dist-info/RECORD,,
-mcp_server_if-0.1.0.dist-info/WHEEL,sha256=hjZsBS66YMok_dT7wQSTJC0OsKhPojW1tCbjA-hXXlg,102
-mcp_server_if-0.1.0.dist-info/entry_points.txt,sha256=Fh-zkWrbgDBe_2UzNjRKYR6vw_kc-q5GnIojwdFS3vk,53
-mcp_server_if-0.1.0.dist-info/METADATA,sha256=S9cnguCgOVHR1GPMDJJWW5IK6zq70cCT-c2R1IpKDRw,5861
-mcp_server_if-0.1.0.dist-info/licenses/LICENSE,sha256=BXxcwr8hEiK-byLXh_amNTuuES4DlNmCmLmQMlVptNY,1072