dev

#!/usr/bin/env python3

# This script is an entrypoint for all developer activities in this project.

import argparse
import os
import subprocess
import sys



def cmd(cmds: argparse._SubParsersAction, name: str, help: str):
    """Decorator that registers subcommands as functions to be executed."""

    def wrapper(func):
        p = cmds.add_parser(name, help=help, add_help=False)
        p.set_defaults(func=func)
        return p

    return wrapper


def run(cmd: str, args: list = [], capture_output=False, env: os._Environ = os.environ):
    """Helper to run cmd in a shell."""
    if args:
        if args[0] == "--":
            args = args[1:]
        cmd += " -- " + " ".join(args)
    return subprocess.run(
        cmd, check=True, shell=True, capture_output=capture_output, env=env
    )



def main():
    if not os.getenv("DIRENV_DIR"):
        print("Direnv is not enabled. Fix it first! See README.md for instructions.")
        sys.exit(1)

    cli = argparse.ArgumentParser(
        usage="./dev COMMAND [FLAGS...]",
        description="CLI for developing Seed Hyper Media. Provides commands for most common developer tasks in this project.",
    )

    cmds = cli.add_subparsers(
        title="commands",
        # This is ugly, but otherwise argparse prints the redundant list of subcommands.
        # And if we just use an empty string it messes up help message alignment for some subcommands.
        metavar="                                                     ",
    )

    @cmd(
        cmds,
        "gen",
        "Check the generated code is up to date and run the code generation process to fix it.",
    )
    def gen(args):
        targets_to_check = (
            run(
                f"plz query filter -i 'generated:check' {str.join(' ', args)}",
                capture_output=True,
            )
            .stdout.decode("utf-8")
            .split("\n")
        )

        out = run(f"plz run parallel {' '.join(targets_to_check)}", capture_output=True)

        targets_to_gen = []
        for line in out.stdout.decode("utf-8").split("\n"):
            idx = line.find("plz run")
            if idx == -1:
                continue
            targets_to_gen.append(line[idx + 7 : -1])  # 7 is length of 'plz run'

        if len(targets_to_gen) == 0:
            return
        return run("plz run parallel " + " ".join(targets_to_gen))

    @cmd(cmds, "run-desktop", "Run frontend desktop app for development.")
    def run_desktop(args):
        run("node scripts/cleanup-desktop.js")
        run("plz build //:pnpm")

        if "SEED_NO_DAEMON_SPAWN" not in os.environ:
            run("plz build //backend:seed-daemon")

        return run("pnpm desktop", args=args)

    @cmd(
        cmds,
        "2-run-desktop",
        "Run TWO desktop instances: packages SeedDev.app for instance B (alt ports + alt appdata), ad-hoc signs it, launches its binary directly to bypass Gatekeeper, then runs the normal dev in the foreground. Pass --skip-package to reuse the existing packaged build.",
    )
    def run_desktop_2(args):
        import atexit
        import pathlib
        import platform
        import time

        skip_package = "--skip-package" in args
        forward_args = [a for a in args if a != "--skip-package"]

        # Alt instance ports/appdata — bumped by +100 from the standard dev values in .env.vars.
        # Packaged bundle is Seed.app (forge.config.ts IS_PROD_DEV reads from package.json,
        # not an env var). Launching the Mach-O binary directly (not via `open`) avoids
        # LaunchServices bundle-id registration, so two Seed.app copies coexist fine as long as
        # their userData paths (VITE_DESKTOP_APPDATA) and daemon ports differ.
        # Each instance gets its own VITE_VERSION so the in-app version label /
        # debug indicator make it obvious which window is which. Instance B's
        # value is baked at package time; instance A's is set at dev launch.
        instance_a_version = os.environ.get("VITE_VERSION", "0.0.0.local") + "-A"
        instance_b_version = os.environ.get("VITE_VERSION", "0.0.0.local") + "-B"

        alt_env_overrides = {
            "VITE_DESKTOP_P2P_PORT": "58100",
            "VITE_DESKTOP_HTTP_PORT": "58101",
            "VITE_DESKTOP_GRPC_PORT": "58102",
            "VITE_METRIC_SERVER_HTTP_PORT": "58103",
            "VITE_DESKTOP_API_PORT": "58104",
            "VITE_DESKTOP_APPDATA": "Seed-local-2",
            "DAEMON_HTTP_PORT": "58101",
            "DAEMON_HTTP_URL": "http://localhost:58101",
            "DAEMON_FILE_URL": "http://localhost:58101",
            "SEED_P2P_PORT": "58100",
            "SEED_HTTP_PORT": "58101",
            "SEED_GRPC_PORT": "58102",
            "SEED_P2P_TESTNET_NAME": os.environ.get("SEED_P2P_TESTNET_NAME", "dev"),
            "VITE_VERSION": instance_b_version,
        }

        desktop_dir = pathlib.Path("frontend/apps/desktop").resolve()
        system = platform.system()
        machine = platform.machine()
        arch = "arm64" if machine in ("arm64", "aarch64") else "x64"

        if system == "Darwin":
            app_bundle = desktop_dir / "out" / f"Seed-darwin-{arch}" / "Seed.app"
            binary_path = app_bundle / "Contents" / "MacOS" / "Seed"
        elif system == "Linux":
            app_bundle = desktop_dir / "out" / f"Seed-linux-{arch}"
            binary_path = app_bundle / "Seed"
        else:
            app_bundle = desktop_dir / "out" / f"Seed-win32-{arch}"
            binary_path = app_bundle / "Seed.exe"

        if skip_package:
            print(
                "⚠️  --skip-package: Instance B will run the EXISTING packaged bundle. "
                "If you've changed renderer/main source since the last package, the dev "
                "instance (A) will see your changes but the packaged instance (B) will "
                "NOT. Re-run without --skip-package to repackage with current source."
            )

        if not skip_package:
            run("node scripts/cleanup-desktop.js")
            run("plz build //:pnpm")
            if "SEED_NO_DAEMON_SPAWN" not in os.environ:
                run("plz build //backend:seed-daemon")

            package_env = os.environ.copy()
            package_env.update(alt_env_overrides)
            print(
                "📦 Packaging Seed.app for instance B (alt ports + alt appdata '{}')…".format(
                    alt_env_overrides["VITE_DESKTOP_APPDATA"]
                )
            )
            run("pnpm --filter @shm/desktop package", env=package_env)

        if not binary_path.exists():
            print(f"❌ Packaged binary not found at {binary_path}. Re-run without --skip-package.")
            sys.exit(1)

        # macOS bundle: ad-hoc codesign + strip quarantine xattr. Launching the
        # Mach-O binary directly (not via `open`) bypasses Gatekeeper's
        # LaunchServices check, but hardened-runtime Electron still needs a
        # valid (ad-hoc) signature or it fails with "cannot be opened because
        # of a problem." Sign AFTER any file mutations.
        if system == "Darwin":
            subprocess.run(
                f'xattr -cr "{app_bundle}" 2>/dev/null || true',
                shell=True,
            )
            sign = subprocess.run(
                f'codesign --force --deep --sign - "{app_bundle}"',
                shell=True,
                capture_output=True,
            )
            if sign.returncode != 0:
                print("⚠️  codesign --sign - failed:")
                print(sign.stderr.decode("utf-8", errors="replace"))

        log_path = os.path.abspath(".ai/desktop-2.log")
        os.makedirs(os.path.dirname(log_path), exist_ok=True)
        instance_b_log = open(log_path, "w")
        print(f"📝 Instance B logs → {log_path}")
        print(f"🅱️  Launching {binary_path} (version '{instance_b_version}')")
        instance_b_env = os.environ.copy()
        instance_b_env.update(alt_env_overrides)
        instance_b = subprocess.Popen(
            [str(binary_path)],
            env=instance_b_env,
            stdout=instance_b_log,
            stderr=subprocess.STDOUT,
            start_new_session=True,
        )

        def stop_instance_b():
            if instance_b.poll() is None:
                print(f"🛑 Stopping instance B (pid {instance_b.pid})…")
                try:
                    os.killpg(os.getpgid(instance_b.pid), 15)
                except ProcessLookupError:
                    pass

        atexit.register(stop_instance_b)

        # Give instance B a couple of seconds to fail fast on bad bundle / signing
        # before we fire up instance A.
        for _ in range(3):
            time.sleep(1)
            if instance_b.poll() is not None:
                print(f"❌ Instance B exited early (code {instance_b.returncode}). Check {log_path}.")
                sys.exit(1)

        print(f"🅰️  Starting instance A (dev ports, appdata 'Seed-local', version '{instance_a_version}')…")
        instance_a_env = os.environ.copy()
        instance_a_env["VITE_VERSION"] = instance_a_version
        try:
            return run("pnpm desktop", args=forward_args, env=instance_a_env)
        finally:
            stop_instance_b()

    @cmd(cmds, "run-desktop-mainnet", "Run frontend desktop app for dev, on mainnet.")
    def run_desktop_mainnet(args):
        run("node scripts/cleanup-desktop.js")
        run("plz build //:pnpm")

        if "SEED_NO_DAEMON_SPAWN" not in os.environ:
            run("plz build //backend:seed-daemon")

        del os.environ["SEED_P2P_TESTNET_NAME"]

        return run("pnpm desktop", args=args)

    @cmd(cmds, "run-desktop-profiler", "Run desktop app with memory profiler window.")
    def run_desktop_profiler(args):
        run("node scripts/cleanup-desktop.js")
        run("plz build //:pnpm")

        if "SEED_NO_DAEMON_SPAWN" not in os.environ:
            run("plz build //backend:seed-daemon")

        os.environ["MEMORY_PROFILER"] = "1"

        return run("pnpm desktop", args=args)

    @cmd(cmds, "run-desktop-fixture", "Run desktop app against test fixture data.")
    def run_desktop_fixture(args):
        run("plz build //:pnpm")

        if "SEED_NO_DAEMON_SPAWN" not in os.environ:
            run("plz build //backend:seed-daemon")

        # Point entire desktop userData to fixture directory
        fixture_dir = os.path.abspath("test-fixtures/desktop")
        os.environ["SEED_FIXTURE_DATA_DIR"] = fixture_dir
        os.environ["SEED_P2P_TESTNET_NAME"] = "fixture"

        return run("pnpm desktop", args=args)

    @cmd(cmds, "build-desktop", "Builds the desktop app for the current platform. Use --profiler to enable React Profiler.")
    def build_desktop(args):
        # run("node scripts/cleanup-desktop.js")
        # run("./scripts/cleanup-frontend.sh")
        run("pnpm install")
        run("plz build //backend:seed-daemon //:pnpm")

        # build-desktop always targets mainnet, regardless of the ambient SEED_P2P_TESTNET_NAME.
        os.environ["SEED_P2P_TESTNET_NAME"] = ""
        os.environ["VITE_LIGHTNING_API_URL"] = "https://ln.seed.hyper.media"
        host_url = "https://host.seed.hyper.media"
        gateway_url = "https://hyper.media"

        # Enable React Profiler if --profiler flag is passed
        if "--profiler" in args:
            os.environ["REACT_PROFILER"] = "1"
            args = [a for a in args if a != "--profiler"]

        env_prefix = f"VITE_DESKTOP_APPDATA=Seed-local SHOW_OB_RESET_BTN=0 VITE_SEED_HOST_URL={host_url} VITE_GATEWAY_URL={gateway_url}"
        if os.environ.get("REACT_PROFILER"):
            env_prefix = f"REACT_PROFILER=1 {env_prefix}"
        run(f"{env_prefix} pnpm desktop:make")

    @cmd(cmds, "test-desktop", "Run frontend desktop tests.")
    def test_desktop(args):
        run("node scripts/cleanup-desktop.js")
        run("plz build //backend:seed-daemon //:pnpm")

        testnet_var = "SEED_P2P_TESTNET_NAME"
        if testnet_var not in os.environ:
            os.environ[testnet_var] = "dev"

        return run("pnpm desktop:test", args=args)

    @cmd(cmds, "run-web", "Run Web app for development.")
    def run_web(args):
        run("./scripts/cleanup-web.sh")
        run("pnpm install")
        run("plz build //:pnpm")
        return run(
            "pnpm web",
            args=args,
        )

    @cmd(cmds, "build-web", "Build web app for production.")
    def build_web(args):
        run("./scripts/cleanup-frontend.sh")
        run("./scripts/cleanup-web.sh")
        run("pnpm install")
        run("plz build //:pnpm")
        return run(
            "pnpm web:prod",
            args=args,
        )

    @cmd(cmds, "frontend-validate", "Formats, Validates")
    def frontend_validate(args):
        run("node scripts/cleanup-desktop.js")
        run("pnpm validate")

    @cmd(
        cmds,
        "run-backend",
        "Build and run seed-daemon binary for the current platform.",
    )
    def run_backend(args):
        env = os.environ.copy()
        env["LLAMA_LOG"] = "error"
        return run("plz run //backend:seed-daemon", args=args, env=env)

    @cmd(cmds, "build-backend", "Build seed-daemon binary for the current platform.")
    def build_backend(args):
        return run("plz build //backend:seed-daemon")

    @cmd(cmds, "run-gw-backend", "Build and run backend for seed web gateway.")
    def run_gateway(args):
        return run("plz run //backend:seed-gateway", args=args)

    @cmd(cmds, "ping-p2p", "Execute ping utility to check visibility.")
    def ping_p2p(args):
        return run("plz run //backend:pingp2p", args=args)

    @cmd(
        cmds,
        "install-cli",
        "Build and install the seed-cli command into ~/.local/bin.",
    )
    def install_cli(args):
        import pathlib

        run("pnpm install")
        run("pnpm --filter @seed-hypermedia/cli build")

        cli_dist = pathlib.Path(__file__).resolve().parent / "frontend" / "apps" / "cli" / "dist" / "index.js"
        if not cli_dist.exists():
            print(f"Error: build output not found at {cli_dist}")
            sys.exit(1)

        bin_dir = pathlib.Path.home() / ".local" / "bin"
        bin_dir.mkdir(parents=True, exist_ok=True)
        link = bin_dir / "seed-cli"
        if link.exists() or link.is_symlink():
            link.unlink()
        link.symlink_to(cli_dist)
        print(f"Installed: {link} -> {cli_dist}")

    @cmd(
        cmds,
        "release",
        "Create a new Release. this will create a new tag and push it to the remote repository",
    )
    def release(args):
        # run("pnpm validate")
        # run("pnpm test")
        run("node scripts/tag.mjs")

    if len(sys.argv) == 1:
        cli.print_help()
        return

    namespace, args = cli.parse_known_args()

    try:
        namespace.func(args)
    except ValueError as err:
        print(str(err))
        sys.exit(1)
    except subprocess.CalledProcessError:
        sys.exit(1)
    except KeyboardInterrupt:
        return


if __name__ == "__main__":
    main()