Wrapper script to make Antigravity CLI work w/ fff-mcp

[eightseventhreethree]

EDIT Stuck initializing

Forced to use Antigravity agy cli and its low quality harness with tons of documentation errors and gaps. This is a wrapper in order to make fff-mcp work

#!/usr/bin/env python3
"""
FFF MCP Server Wrapper for Antigravity / Gemini CLI & IDE
Intercepts pre-initialization discovery requests (e.g. 'server/discover') from the host client
and responds with Method Not Found so the host proceeds to standard MCP 'initialize'.
"""

import os
import sys
import json
import subprocess
import threading

FFF_MCP_BIN = os.path.expandvars(
    os.path.expanduser(os.environ.get("FFF_MCP_BIN", "$HOME/.local/bin/fff-mcp"))
)


def pipe_stream(src, dst):
    try:
        while True:
            chunk = src.read(4096)
            if not chunk:
                break
            dst.write(chunk)
            dst.flush()
    except Exception:
        pass
    finally:
        try:
            dst.close()
        except Exception:
            pass


def main():
    buffered_line = None

    # Intercept any pre-initialization discovery calls from Antigravity/Gemini host
    while True:
        line_bytes = sys.stdin.buffer.readline()
        if not line_bytes:
            return

        try:
            data = json.loads(line_bytes.decode("utf-8", errors="replace"))
            if isinstance(data, dict) and data.get("method") == "server/discover":
                req_id = data.get("id")
                resp = {
                    "jsonrpc": "2.0",
                    "id": req_id,
                    "error": {
                        "code": -32601,
                        "message": "Method not found: server/discover",
                    },
                }
                sys.stdout.buffer.write((json.dumps(resp) + "\n").encode("utf-8"))
                sys.stdout.buffer.flush()
                continue
        except Exception:
            pass

        buffered_line = line_bytes
        break

    # Spawn real fff-mcp binary
    proc = subprocess.Popen(
        [FFF_MCP_BIN] + sys.argv[1:],
        stdin=subprocess.PIPE,
        stdout=subprocess.PIPE,
        stderr=sys.stderr,
        bufsize=0,
    )

    if buffered_line:
        proc.stdin.write(buffered_line)
        proc.stdin.flush()

    # Pass binary streams bidirectionally
    t_in = threading.Thread(
        target=pipe_stream, args=(sys.stdin.buffer, proc.stdin), daemon=True
    )
    t_out = threading.Thread(
        target=pipe_stream, args=(proc.stdout, sys.stdout.buffer), daemon=True
    )

    t_in.start()
    t_out.start()

    proc.wait()


if __name__ == "__main__":
    main()

Then in mcp_config.json ~/.gemini/config/mcp_config.json

{
  "mcpServers": {
    "fff": {
      "command": "~/.local/bin/fff-mcp-wrapper"
    }
  }
}