opencode_mobile_bridge.py

import argparse
import atexit
import json
import os
from pathlib import Path
import shutil
import socket
import subprocess
import sys
import threading
import time
import urllib.error
import urllib.request
import webbrowser


DEFAULT_UPSTREAM_HOST = "127.0.0.1"
DEFAULT_UPSTREAM_PORT = 4097
DEFAULT_PROXY_HOST = "0.0.0.0"
DEFAULT_PROXY_PORT = 4096
DEFAULT_OPENCODE_PACKAGE = "opencode-ai@latest"
DEFAULT_OPENCODE_SUBCOMMAND = "serve"
BRIDGE_PROXY_VERSION = "0.2.0"


def command_exists(command: str | None) -> bool:
    if not command:
        return False

    if Path(command).exists():
        return True

    return shutil.which(command) is not None


def prepend_path(directory: Path) -> None:
    if not directory.exists():
        return

    current = os.environ.get("PATH", "")
    parts = current.split(os.pathsep) if current else []
    directory_text = str(directory)
    if any(part.lower() == directory_text.lower() for part in parts):
        return

    os.environ["PATH"] = directory_text + os.pathsep + current if current else directory_text


def refresh_node_path() -> None:
    if os.name != "nt":
        return

    for env_name in ("ProgramFiles", "ProgramFiles(x86)"):
        root = os.environ.get(env_name)
        if root:
            prepend_path(Path(root) / "nodejs")

    appdata = os.environ.get("APPDATA")
    if appdata:
        prepend_path(Path(appdata) / "npm")


def known_windows_executable(*names: str) -> str | None:
    if os.name != "nt":
        return None

    directories: list[Path] = []
    for env_name in ("ProgramFiles", "ProgramFiles(x86)"):
        root = os.environ.get(env_name)
        if root:
            directories.append(Path(root) / "nodejs")

    appdata = os.environ.get("APPDATA")
    if appdata:
        directories.append(Path(appdata) / "npm")

    for directory in directories:
        for name in names:
            candidate = directory / name
            if candidate.exists():
                return str(candidate)

    return None


def find_npm_command() -> str | None:
    refresh_node_path()

    if os.name == "nt":
        return shutil.which("npm.cmd") or shutil.which("npm") or known_windows_executable("npm.cmd", "npm.exe")

    return shutil.which("npm")


def default_node_command() -> str | None:
    configured = os.environ.get("NODE_CMD")
    if configured:
        return configured

    refresh_node_path()
    found = shutil.which("node")
    if found:
        return found

    return known_windows_executable("node.exe")


def resolve_node_command(preferred: str | None) -> str | None:
    refresh_node_path()
    candidates = []
    if preferred:
        candidates.append(preferred)

    detected = default_node_command()
    if detected:
        candidates.append(detected)

    candidates.append("node")

    for candidate in candidates:
        if command_exists(candidate):
            return candidate

    return None


def install_nodejs() -> bool:
    if os.name == "nt":
        winget = shutil.which("winget")
        if not winget:
            print("Node.js was not found and winget is not available to install it automatically.", file=sys.stderr, flush=True)
            print("Install Node.js LTS from https://nodejs.org/ and run this script again.", file=sys.stderr, flush=True)
            return False

        print("Node.js was not found. Installing Node.js LTS with winget...", flush=True)
        result = subprocess.run(
            [
                winget,
                "install",
                "--id",
                "OpenJS.NodeJS.LTS",
                "-e",
                "--accept-package-agreements",
                "--accept-source-agreements",
            ]
        )
        refresh_node_path()
        return result.returncode == 0 and resolve_node_command(None) is not None

    if sys.platform == "darwin":
        brew = shutil.which("brew")
        if not brew:
            print("Node.js was not found and Homebrew is not available to install it automatically.", file=sys.stderr, flush=True)
            print("Install Node.js LTS from https://nodejs.org/ and run this script again.", file=sys.stderr, flush=True)
            return False

        print("Node.js was not found. Installing Node.js with Homebrew...", flush=True)
        result = subprocess.run([brew, "install", "node"])
        return result.returncode == 0 and resolve_node_command(None) is not None

    print("Node.js was not found. Automatic Node.js install is currently supported on Windows and macOS only.", file=sys.stderr, flush=True)
    print("Install Node.js LTS from https://nodejs.org/ and run this script again.", file=sys.stderr, flush=True)
    return False


def ensure_node_command(preferred: str | None, auto_install: bool) -> str | None:
    command = resolve_node_command(preferred)
    if command:
        return command

    if not auto_install:
        return None

    if not install_nodejs():
        return None

    return resolve_node_command(preferred)


def default_opencode_command() -> str | None:
    configured = os.environ.get("OPENCODE_CMD")
    if configured:
        return configured

    if os.name == "nt":
        appdata = os.environ.get("APPDATA", "")
        candidate = Path(appdata) / "npm" / "opencode.cmd"
        if candidate.exists():
            return str(candidate)

    found = shutil.which("opencode")
    return found


def resolve_opencode_command(preferred: str | None) -> str | None:
    candidates = []
    if preferred:
        candidates.append(preferred)

    detected = default_opencode_command()
    if detected:
        candidates.append(detected)

    candidates.append("opencode")

    for candidate in candidates:
        if command_exists(candidate):
            return candidate

    return None


def install_opencode_cli(package: str) -> bool:
    npm = find_npm_command()
    if not npm:
        print("npm was not found. Install Node.js first, then run this script again.", file=sys.stderr, flush=True)
        return False

    print(f"OpenCode CLI was not found. Installing {package} with npm...", flush=True)
    result = subprocess.run([npm, "install", "-g", package])
    return result.returncode == 0


def ensure_opencode_command(preferred: str | None, package: str, auto_install: bool) -> str | None:
    command = resolve_opencode_command(preferred)
    if command:
        return command

    if not auto_install:
        return None

    if not install_opencode_cli(package):
        return None

    return resolve_opencode_command(preferred)


def default_desktop_global_path() -> str:
    if os.name == "nt":
        appdata = os.environ.get("APPDATA", "")
        return str(Path(appdata) / "ai.opencode.desktop" / "opencode.global.dat")

    home = Path.home()
    macos = home / "Library" / "Application Support" / "ai.opencode.desktop" / "opencode.global.dat"
    linux = home / ".config" / "ai.opencode.desktop" / "opencode.global.dat"
    return str(macos if macos.exists() else linux)


def get_lan_ip() -> str:
    sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    try:
        sock.connect(("8.8.8.8", 80))
        return sock.getsockname()[0]
    except OSError:
        try:
            return socket.gethostbyname(socket.gethostname())
        except OSError:
            return "127.0.0.1"
    finally:
        sock.close()


def connect_host(host: str) -> str:
    if host in ("", "0.0.0.0", "::"):
        return "127.0.0.1"
    return host


def can_connect(host: str, port: int) -> bool:
    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
        sock.settimeout(1)
        try:
            sock.connect((connect_host(host), port))
            return True
        except OSError:
            return False


def wait_for_port(host: str, port: int, timeout: float) -> bool:
    deadline = time.time() + timeout
    while time.time() < deadline:
        if can_connect(host, port):
            return True
        time.sleep(0.25)
    return False


def request_json(url: str) -> dict | None:
    try:
        with urllib.request.urlopen(url, timeout=2) as response:
            return json.loads(response.read().decode("utf-8"))
    except (OSError, urllib.error.URLError, json.JSONDecodeError):
        return None


def http_status(url: str) -> int | None:
    try:
        request = urllib.request.Request(url, method="GET")
        with urllib.request.urlopen(request, timeout=2) as response:
            return response.status
    except urllib.error.HTTPError as error:
        return error.code
    except (OSError, urllib.error.URLError):
        return None


def bridge_health(host: str, port: int) -> dict | None:
    return request_json(f"http://{connect_host(host)}:{port}/__health")


def bridge_projects(host: str, port: int) -> dict | None:
    return request_json(f"http://{connect_host(host)}:{port}/__projects")


def wait_for_bridge_projects(host: str, port: int, timeout: float) -> dict | None:
    deadline = time.time() + timeout
    last_result = None

    while time.time() < deadline:
        result = bridge_projects(host, port)
        if result is not None:
            last_result = result
            if result.get("projects"):
                return result
        time.sleep(0.5)

    return last_result


def summarize_projects(result: dict | None) -> str:
    if not result:
        return "Project discovery did not return diagnostics."

    projects = result.get("projects") or []
    diagnostics = result.get("diagnostics") or {}
    return (
        f"Discovered {len(projects)} projects "
        f"(manual={diagnostics.get('manual', 0)}, "
        f"desktop={diagnostics.get('desktop', 0)}, "
        f"upstream={diagnostics.get('upstream', 0)})."
    )


def stream_output(process: subprocess.Popen, label: str) -> None:
    if not process.stdout:
        return

    for line in iter(process.stdout.readline, ""):
        if line:
            print(f"[{label}] {line.rstrip()}", flush=True)
        if process.poll() is not None:
            break


def terminate(processes: list[subprocess.Popen]) -> None:
    for process in processes:
        if process.poll() is None:
            process.terminate()

    deadline = time.time() + 5
    for process in processes:
        while process.poll() is None and time.time() < deadline:
            time.sleep(0.1)
        if process.poll() is None:
            process.kill()


def stop_process_on_port(port: int) -> bool:
    if os.name == "nt":
        command = [
            "powershell",
            "-NoProfile",
            "-NonInteractive",
            "-Command",
            (
                "$ids = Get-NetTCPConnection -LocalPort "
                + str(port)
                + " -State Listen -ErrorAction SilentlyContinue | Select-Object -ExpandProperty OwningProcess -Unique; "
                + "if ($ids) { $ids | ForEach-Object { Stop-Process -Id $_ -Force -ErrorAction SilentlyContinue }; exit 0 } else { exit 1 }"
            ),
        ]
    else:
        shell_command = (
            "ids=$(lsof -ti tcp:" + str(port) + " -sTCP:LISTEN 2>/dev/null); "
            "if [ -n \"$ids\" ]; then kill $ids; exit 0; else exit 1; fi"
        )
        command = ["sh", "-c", shell_command]

    try:
        return subprocess.run(command, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL).returncode == 0
    except OSError:
        return False


def build_parser() -> argparse.ArgumentParser:
    parser = argparse.ArgumentParser(
        description="Expose OpenCode Web UI on your LAN and seed Desktop projects for mobile browsers.",
    )
    parser.add_argument(
        "--opencode",
        default=default_opencode_command(),
        help="Path to opencode executable. If missing, the script installs OpenCode with npm by default.",
    )
    parser.add_argument(
        "--opencode-package",
        default=DEFAULT_OPENCODE_PACKAGE,
        help="npm package to install when OpenCode CLI is missing.",
    )
    parser.add_argument(
        "--no-install-opencode",
        action="store_true",
        help="Fail instead of installing OpenCode CLI when it is missing.",
    )
    parser.add_argument(
        "--opencode-subcommand",
        choices=("serve", "web"),
        default=DEFAULT_OPENCODE_SUBCOMMAND,
        help="OpenCode command used to start the upstream server. 'serve' avoids opening an empty browser tab.",
    )
    parser.add_argument(
        "--node",
        default=default_node_command(),
        help="Path to node executable. If missing, the script installs Node.js when possible.",
    )
    parser.add_argument(
        "--no-install-node",
        action="store_true",
        help="Fail instead of installing Node.js when it is missing.",
    )
    parser.add_argument("--upstream-host", default=DEFAULT_UPSTREAM_HOST, help="Host for the private OpenCode server.")
    parser.add_argument("--upstream-port", type=int, default=DEFAULT_UPSTREAM_PORT, help="Port for the private OpenCode server.")
    parser.add_argument("--proxy-host", default=DEFAULT_PROXY_HOST, help="Host for the LAN proxy.")
    parser.add_argument("--proxy-port", type=int, default=DEFAULT_PROXY_PORT, help="Port for the LAN proxy.")
    parser.add_argument(
        "--desktop-global",
        default=default_desktop_global_path(),
        help="Path to OpenCode Desktop opencode.global.dat for project import.",
    )
    parser.add_argument(
        "--seed-project",
        action="append",
        default=[],
        help="Extra project path to seed into the mobile/browser project list. Can be used multiple times.",
    )
    parser.add_argument(
        "--keep-auth",
        action="store_true",
        help="Do not remove OPENCODE_SERVER_PASSWORD/USERNAME before starting OpenCode.",
    )
    parser.add_argument(
        "--startup-timeout",
        type=float,
        default=20,
        help="Seconds to wait for OpenCode before starting the proxy.",
    )
    parser.add_argument(
        "--project-timeout",
        type=float,
        default=15,
        help="Seconds to wait for project discovery before opening the browser.",
    )
    parser.add_argument(
        "--no-open",
        action="store_true",
        help="Do not open a browser automatically after seeding is ready.",
    )
    parser.add_argument(
        "--no-restart-outdated-proxy",
        action="store_true",
        help="Do not automatically stop an older OpenCode Mobile Bridge proxy on the same port.",
    )
    parser.add_argument(
        "--open-target",
        choices=("seed", "ui", "projects"),
        default="seed",
        help="Page to open automatically. 'seed' updates project localStorage before redirecting to the UI.",
    )
    return parser


def main() -> int:
    args = build_parser().parse_args()
    project_dir = Path(__file__).resolve().parent
    proxy_script = project_dir / "bridge_proxy.js"

    if not proxy_script.exists():
        print(f"Proxy script not found: {proxy_script}", file=sys.stderr, flush=True)
        return 1

    env = os.environ.copy()
    if not args.keep_auth:
        env.pop("OPENCODE_SERVER_PASSWORD", None)
        env.pop("OPENCODE_SERVER_USERNAME", None)

    env["OPENCODE_UPSTREAM_HOST"] = args.upstream_host
    env["OPENCODE_UPSTREAM_PORT"] = str(args.upstream_port)
    env["OPENCODE_PROXY_HOST"] = args.proxy_host
    env["OPENCODE_PROXY_PORT"] = str(args.proxy_port)
    env["OPENCODE_DESKTOP_GLOBAL"] = args.desktop_global
    env["OPENCODE_SEED_PROJECTS"] = ";".join(args.seed_project)

    print("OpenCode Mobile Bridge", flush=True)
    print(f"Desktop project state: {args.desktop_global}", flush=True)
    processes: list[subprocess.Popen] = []
    atexit.register(lambda: terminate(processes))

    node_command = ensure_node_command(args.node, auto_install=not args.no_install_node)
    if not node_command:
        print("Node.js is not installed or could not be found.", file=sys.stderr, flush=True)
        print("Install Node.js LTS from https://nodejs.org/ and run this script again.", file=sys.stderr, flush=True)
        return 1
    env["PATH"] = os.environ.get("PATH", env.get("PATH", ""))
    print(f"Node.js command: {node_command}", flush=True)

    upstream_url = f"http://{connect_host(args.upstream_host)}:{args.upstream_port}/"
    upstream_running = can_connect(args.upstream_host, args.upstream_port)

    if upstream_running:
        print(f"Found an existing OpenCode server on {upstream_url}; reusing it.", flush=True)
        status = http_status(upstream_url)
        if status == 401:
            print("Warning: the existing OpenCode server is asking for HTTP basic auth.", flush=True)
            print("Stop that server and rerun this script if you want the bridge to launch a no-auth server.", flush=True)
        elif not args.keep_auth:
            print("Auth env vars only affect servers launched by this script; existing server auth is unchanged.", flush=True)
    else:
        opencode_command = ensure_opencode_command(
            args.opencode,
            args.opencode_package,
            auto_install=not args.no_install_opencode,
        )
        if not opencode_command:
            print("OpenCode CLI is not installed or could not be found.", file=sys.stderr, flush=True)
            print("Install it with: npm install -g opencode-ai@latest", file=sys.stderr, flush=True)
            return 1

        print(f"OpenCode command: {opencode_command}", flush=True)
        if not args.keep_auth:
            print("HTTP basic auth env vars will be removed for the launched server.", flush=True)

        server_command = [
            opencode_command,
            args.opencode_subcommand,
            "--hostname",
            args.upstream_host,
            "--port",
            str(args.upstream_port),
        ]

        print(
            f"Starting OpenCode {args.opencode_subcommand} on http://{args.upstream_host}:{args.upstream_port}/",
            flush=True,
        )
        server_process = subprocess.Popen(
            server_command,
            env=env,
            stdout=subprocess.PIPE,
            stderr=subprocess.STDOUT,
            text=True,
            bufsize=1,
        )
        processes.append(server_process)
        threading.Thread(target=stream_output, args=(server_process, "opencode"), daemon=True).start()

        if not wait_for_port(args.upstream_host, args.upstream_port, args.startup_timeout):
            print("Warning: OpenCode did not accept connections before the startup timeout.", flush=True)
            print("The proxy will still start; check OpenCode output for startup errors.", flush=True)

    proxy = bridge_health(args.proxy_host, args.proxy_port)
    if proxy and proxy.get("version") != BRIDGE_PROXY_VERSION:
        message = (
            "Found an older OpenCode Mobile Bridge proxy "
            f"on http://{connect_host(args.proxy_host)}:{args.proxy_port}/ "
            f"(version={proxy.get('version') or 'unknown'})."
        )
        if args.no_restart_outdated_proxy:
            print(message, flush=True)
            print("Reusing it because --no-restart-outdated-proxy was set.", flush=True)
        else:
            print(message, flush=True)
            print("Restarting it so the fixed seed page is used.", flush=True)
            if stop_process_on_port(args.proxy_port) and wait_for_port(args.proxy_host, args.proxy_port, 2):
                print("Warning: old proxy is still accepting connections after restart attempt.", flush=True)
            time.sleep(0.5)
            proxy = bridge_health(args.proxy_host, args.proxy_port)
            if proxy and proxy.get("version") != BRIDGE_PROXY_VERSION:
                print("Could not replace the older proxy. Stop the old bridge process and run this script again.", file=sys.stderr, flush=True)
                terminate(processes)
                return 1

    if proxy:
        print(f"Found an existing OpenCode Mobile Bridge proxy on http://{connect_host(args.proxy_host)}:{args.proxy_port}/; reusing it.", flush=True)
    elif can_connect(args.proxy_host, args.proxy_port):
        print(f"Port {args.proxy_port} is already in use, but it does not look like OpenCode Mobile Bridge.", file=sys.stderr, flush=True)
        print("Stop the process using that port or rerun with --proxy-port <free-port>.", file=sys.stderr, flush=True)
        terminate(processes)
        return 1
    else:
        print(f"Starting LAN proxy on http://{args.proxy_host}:{args.proxy_port}/", flush=True)
        proxy_process = subprocess.Popen(
            [node_command, str(proxy_script)],
            env=env,
            stdout=subprocess.PIPE,
            stderr=subprocess.STDOUT,
            text=True,
            bufsize=1,
        )
        processes.append(proxy_process)
        threading.Thread(target=stream_output, args=(proxy_process, "proxy"), daemon=True).start()

    if not wait_for_port(args.proxy_host, args.proxy_port, args.startup_timeout):
        print("Warning: bridge proxy did not accept connections before the startup timeout.", flush=True)

    lan_ip = get_lan_ip()
    lan_ui_url = f"http://{lan_ip}:{args.proxy_port}/"
    lan_seed_url = f"http://{lan_ip}:{args.proxy_port}/__seed"
    lan_projects_url = f"http://{lan_ip}:{args.proxy_port}/__projects"

    print("Checking project discovery before opening the browser...", flush=True)
    project_result = wait_for_bridge_projects(args.proxy_host, args.proxy_port, args.project_timeout)
    print(summarize_projects(project_result), flush=True)

    projects = (project_result or {}).get("projects") or []
    diagnostics = (project_result or {}).get("diagnostics") or {}
    if diagnostics.get("desktopError"):
        print(f"Desktop project import warning: {diagnostics['desktopError']}", flush=True)
    if diagnostics.get("upstreamError"):
        print(f"OpenCode project API warning: {diagnostics['upstreamError']}", flush=True)

    open_targets = {
        "seed": lan_seed_url,
        "ui": lan_ui_url,
        "projects": lan_projects_url,
    }
    open_url = open_targets[args.open_target]
    if args.open_target == "seed" and not projects:
        open_url = lan_projects_url
        print("No projects were discovered; opening diagnostics instead of the seed page.", flush=True)

    if not args.no_open:
        print(f"Opening {open_url}", flush=True)
        webbrowser.open(open_url)

    print("", flush=True)
    print("Bridge is running.", flush=True)
    print(f"Local OpenCode: http://127.0.0.1:{args.upstream_port}/", flush=True)
    print(f"LAN Web UI:     {lan_ui_url}", flush=True)
    print(f"Seed projects:  {lan_seed_url}", flush=True)
    print(f"Debug projects: {lan_projects_url}", flush=True)
    print("", flush=True)
    print("The seed page writes the latest project list into that browser, then redirects to OpenCode.", flush=True)
    print("Open the seed URL once from each phone/browser after adding new Desktop projects.", flush=True)
    if processes:
        print("Press Ctrl+C to stop processes started by this script.", flush=True)
    else:
        print("Everything was already running; no new processes were started.", flush=True)
        return 0

    try:
        while True:
            for process in processes:
                if process.poll() is not None:
                    print(f"A child process exited with code {process.returncode}; shutting down.", flush=True)
                    terminate(processes)
                    return int(process.returncode or 0)
            time.sleep(0.5)
    except KeyboardInterrupt:
        print("\nStopping bridge...", flush=True)
        terminate(processes)
        return 0


if __name__ == "__main__":
    raise SystemExit(main())