capyy 0.5.2__tar.gz → 0.5.4__tar.gz

{capyy-0.5.2 → capyy-0.5.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: capyy
-Version: 0.5.2
+Version: 0.5.4
 Summary: Easy, encrypted networking for Python: programs that talk (local, Wi-Fi, internet), home automation, and projects run with cy
 Author: Izac
 License-Expression: MIT
@@ -101,6 +101,22 @@ app.call("hello", nom="Izac")   # client side
 `mode` can be `local`, `wifi` or `network` (with `relay`, `key`, `fingerprint`). Strings starting with `$` are read
 from environment variables, e.g. `"key": "$CAPY_KEY"`. Inside a project, the `cy` command runs its `scripts` like `npm run` (`cy test`, `cy start`) and its files (`cy server`); create a project with `capy new`.
 
+## From the terminal
+
+```bash
+capy call localhost:4000 hello nom=Izac        # any capy server (add --no-tls for a plain one)
+capy wifi scan                                 # capy.wifi servers on your network
+capy wifi call home temperature
+capy network call home test --relay my-vps.example:3879 --key "$CAPY_KEY"
+cy call hello nom=Izac                         # inside a project: uses capy.config.json
+```
+
+`capy cli` opens an interactive prompt (history, Tab completion, `cd` between projects). Output is colored in a
+terminal and plain text / JSON in a pipe (set `NO_COLOR=1` to disable colors).
+
+Parameters are `name=value`; numbers, `true`/`false` and lists are parsed (`age=14` sends the number 14).
+The answer is printed as JSON; the exit code is 1 when the server answers `{"erreur": ...}`.
+
 ## Encryption (TLS)
 
 Everything is encrypted by default, with nothing to configure.

{capyy-0.5.2 → capyy-0.5.4}/README.md

@@ -79,6 +79,22 @@ app.call("hello", nom="Izac")   # client side
 `mode` can be `local`, `wifi` or `network` (with `relay`, `key`, `fingerprint`). Strings starting with `$` are read
 from environment variables, e.g. `"key": "$CAPY_KEY"`. Inside a project, the `cy` command runs its `scripts` like `npm run` (`cy test`, `cy start`) and its files (`cy server`); create a project with `capy new`.
 
+## From the terminal
+
+```bash
+capy call localhost:4000 hello nom=Izac        # any capy server (add --no-tls for a plain one)
+capy wifi scan                                 # capy.wifi servers on your network
+capy wifi call home temperature
+capy network call home test --relay my-vps.example:3879 --key "$CAPY_KEY"
+cy call hello nom=Izac                         # inside a project: uses capy.config.json
+```
+
+`capy cli` opens an interactive prompt (history, Tab completion, `cd` between projects). Output is colored in a
+terminal and plain text / JSON in a pipe (set `NO_COLOR=1` to disable colors).
+
+Parameters are `name=value`; numbers, `true`/`false` and lists are parsed (`age=14` sends the number 14).
+The answer is printed as JSON; the exit code is 1 when the server answers `{"erreur": ...}`.
+
 ## Encryption (TLS)
 
 Everything is encrypted by default, with nothing to configure.

capyy-0.5.4/capy/__main__.py

@@ -0,0 +1,541 @@
+# Deux commandes, installées avec capy :
+#
+# cy : DANS un projet capy (un dossier avec capy.config.json, ou en dessous)
+#   cy                          -> montre le projet (nom, mode, adresse, fichiers, scripts…)
+#   cy NOM [args…]              -> lance le script NOM de "scripts" (comme npm run)
+#   cy scripts                  -> liste les scripts
+#   cy server / cy client       -> lance un fichier de "files"
+#   cy run                      -> lance le serveur en fond, puis le client, puis arrête le serveur
+#   cy call ACTION [nom=valeur…] -> appelle une action du serveur du projet (local, wifi ou network)
+#
+# capy : tout le reste (et tout ce que fait cy)
+#   capy cli                    -> le mode interactif : on tape les commandes à la suite (historique, Tab)
+#   capy new NOM [mode]         -> crée un dossier NOM avec capy.config.json, server.py, client.py
+#   capy init [nom] [mode]      -> crée juste capy.config.json ici
+#   capy domo …                 -> la domotique (capy domo help)
+#   capy relay PORT [CLÉ]       -> lance un relais capy.network (sur le VPS)
+#   capy call HÔTE:PORT ACTION [nom=valeur…]       -> appelle une action d'un serveur capy
+#   capy wifi scan / capy wifi call NOM ACTION …   -> les serveurs du wifi
+#   capy network call NOM ACTION … [--relay R --key K]   /   capy network relay PORT [CLÉ]
+#   capy version                -> la version de capy
+#   mode : local (par défaut), wifi ou network
+#   python3 -m capy = capy (si la commande n'est pas dans le PATH)
+
+import difflib
+import json
+import os
+import pathlib as pth
+import re
+import shlex
+import socket
+import subprocess
+import sys
+import threading
+import time
+
+from . import _style as st
+from ._project import COMMANDS, FILE_NAME, MODES, find, init, new, project
+
+OUTSIDE = ("init", "new", "domo", "relay", "wifi", "network")  # Commandes de capy, pas de cy
+
+# L'aide : (section, [(commande, explication)])
+HELP = [
+    ("Dans un projet capy (" + FILE_NAME + ")", [
+        ("cy", "montre le projet"),
+        ("cy NOM [args…]", "lance le script NOM de \"scripts\" (comme npm run)"),
+        ("cy scripts", "liste les scripts"),
+        ("cy server / client", "lance un fichier de \"files\""),
+        ("cy run", "serveur en fond + client, puis arrête le serveur"),
+        ("cy call ACTION [nom=valeur…]", "appelle une action du serveur du projet"),
+    ]),
+    ("Partout", [
+        ("capy cli", "le mode interactif (historique ↑↓, complétion Tab)"),
+        ("capy new NOM [mode]", "crée un projet complet (config, server.py, client.py)"),
+        ("capy init [nom] [mode]", f"crée juste {FILE_NAME} ici"),
+        ("capy call HÔTE:PORT ACTION [nom=valeur…]", "appelle une action (--no-tls pour un serveur en clair)"),
+        ("capy wifi scan", "les serveurs capy du wifi"),
+        ("capy wifi call NOM ACTION [nom=valeur…]", "appelle un serveur du wifi"),
+        ("capy network call NOM ACTION [nom=valeur…]", "par internet (--relay HÔTE:PORT --key CLÉ)"),
+        ("capy relay PORT [CLÉ]", "lance un relais capy.network"),
+        ("capy domo …", "la domotique (capy domo help)"),
+        ("capy version", "la version de capy"),
+    ]),
+]
+
+
+def usage():
+    lines = [st.title("capy", f"v{version()} · le réseau facile en Python"), ""]
+    width = max(len(c) for _, commands in HELP for c, _ in commands)  # Les deux sections alignées ensemble
+    for name, commands in HELP:
+        lines.append(st.section(name))
+        lines += [f"  {st.code(c)}{' ' * (width - len(c) + 3)}{st.paint(d, 'dim')}" for c, d in commands]
+        lines.append("")
+    lines.append(st.paint(f"  Paramètres : nom=Izac age=14 actif=true liste=[1,2]   ·   modes : {', '.join(MODES)}", "dim"))
+    return "\n".join(lines)
+
+
+# La version de capy : celle du pyproject.toml si on tourne depuis le dossier du code (installation éditable,
+# où pip garde la version du jour de l'installation), sinon celle installée par pip
+def version():
+    pyproject = pth.Path(__file__).resolve().parent.parent / "pyproject.toml"
+    if pyproject.is_file():
+        match = re.search(r'^version = "(.+)"', pyproject.read_text(encoding="utf-8"), re.M)
+        if match and 'name = "capyy"' in pyproject.read_text(encoding="utf-8"):
+            return match.group(1)
+    try:
+        from importlib.metadata import version as package_version
+        return package_version("capyy")
+    except Exception:
+        return "?"
+
+
+# Le projet du dossier actuel (ou au-dessus), sinon on explique quoi faire
+def _project():
+    path = find(".")
+    if path is None:
+        sys.exit(f"Pas de {FILE_NAME} ici ni au-dessus : ce dossier n'est pas un projet capy.\n"
+                 f"  Crée un projet : capy new mon-projet\n"
+                 f"  ou juste le fichier : capy init")
+    try:
+        return project(path)
+    except ValueError as e:
+        sys.exit(str(e))
+
+
+# Le projet, joliment (cy sans rien)
+def describe(app):
+    head = st.paint(app.name, bold=True) + (st.paint(f"  v{app.version}", "dim") if app.version else "") \
+        + (st.paint(f"  par {app.author}", "dim") if app.author else "")
+    lines = [f"{st.paint('◆', 'mauve', bold=True)} {head}"]
+    if app.description:
+        lines.append(f"  {app.description}")
+    where = {"local": f"{app.host}:{app.port}", "wifi": f"sur le wifi, nom {app.name!r}",
+             "network": f"relais {app.relay}, nom {app.name!r}"}[app.mode]
+    lock = st.paint("🔒 chiffré", "green") if app.tls else st.paint("en clair", "yellow")
+    lines += ["", st.table([(st.paint("Mode", "dim"), f"{st.paint(app.mode, 'mauve')} · {where} · {lock}"),
+                            (st.paint("Fichier", "dim"), st.paint(str(app.path).replace(str(pth.Path.home()), "~"), "dim"))])]
+    if app.files:
+        lines += ["", st.section("  Fichiers")]
+        rows = []
+        for name, path in app.files.items():
+            shown = path.relative_to(app.folder) if str(path).startswith(str(app.folder)) else path
+            mark = st.paint("✓", "green") if path.is_file() else st.paint("✗", "red")
+            rows.append((mark, st.code(name), str(shown) + ("" if path.is_file() else st.paint("  introuvable", "red"))))
+        lines.append(st.table(rows, indent=4, gap=2))
+    if app.scripts:
+        lines += ["", st.section("  Scripts") + st.paint("   cy NOM pour en lancer un", "dim")]
+        lines.append(st.table([(st.code(name), command) for name, command in app.scripts.items()], indent=4))
+    return "\n".join(lines)
+
+
+# Sortir les options "--nom valeur" (et "--drapeau") d'une liste d'arguments -> (options, reste)
+def _options(args, flags=(), values=()):
+    options, rest, i = {}, [], 0
+    while i < len(args):
+        word = args[i]
+        if word in flags:
+            options[word] = True
+        elif word in values:
+            if i + 1 >= len(args):
+                sys.exit(f"capy : il manque une valeur après {word}")
+            options[word] = args[i + 1]
+            i += 1
+        elif word.startswith("--"):
+            sys.exit(f"capy : option {word} inconnue (possibles : {', '.join((*flags, *values)) or 'aucune'})")
+        else:
+            rest.append(word)
+        i += 1
+    return options, rest
+
+
+# "nom=Izac" "age=14" -> {"nom": "Izac", "age": 14} : une valeur qui est du JSON (14, true, [1, 2]) est convertie
+def _params(words):
+    params = {}
+    for word in words:
+        key, sep, value = word.partition("=")
+        if not sep or not key:
+            sys.exit(f"capy : paramètre {word!r} invalide, écris nom=valeur (ex : nom=Izac age=14)")
+        try:
+            params[key] = json.loads(value)
+        except ValueError:
+            params[key] = value
+    return params
+
+
+# Faire l'appel et afficher la réponse en JSON (coloré dans un terminal) ; code 1 si erreur (pratique dans un script)
+def _call(function):
+    import capy
+    started = time.monotonic()
+    try:
+        answer = function()
+    except (ConnectionError, ValueError, KeyError, capy.SecurityError) as e:
+        sys.exit(str(e).strip("'\""))
+    print(st.pretty(answer))
+    if st.enabled():
+        print(st.paint(f"  {(time.monotonic() - started) * 1000:.0f} ms", "dim"))
+    if isinstance(answer, dict) and "erreur" in answer:
+        sys.exit(1)
+
+
+USAGE_CALL = "Usage : capy call HÔTE:PORT ACTION [nom=valeur…] [--no-tls]   (ex : capy call localhost:4000 hello nom=Izac)"
+
+
+# capy call localhost:4000 hello nom=Izac
+def call_direct(args):
+    import capy
+    options, rest = _options(args, flags=("--no-tls",))
+    if len(rest) < 2:
+        sys.exit(USAGE_CALL)
+    host, _, port = rest[0].rpartition(":")
+    if not host or not port.isdigit():
+        sys.exit(f"capy : adresse {rest[0]!r} invalide, écris HÔTE:PORT (ex : localhost:4000)\n{USAGE_CALL}")
+    _call(lambda: capy.call(host, int(port), rest[1], tls="--no-tls" not in options, **_params(rest[2:])))
+
+
+# capy wifi scan / capy wifi call maison hello nom=Izac
+def wifi(args):
+    import capy.wifi
+    sub = args[0] if args else None
+    if sub == "scan":
+        options, _ = _options(args[1:], values=("--timeout",))
+        if st.enabled():
+            print(st.paint("  Recherche sur le wifi…", "dim"), flush=True)
+        found = capy.wifi.scan(timeout=float(options.get("--timeout", 1)))
+        if not found:
+            sys.exit("Aucun serveur capy.wifi trouvé (même wifi ? wifi public qui isole les appareils ?)")
+        print(st.table([(st.paint("●", "green"), st.code(name), f"{ip}:{port}",
+                         st.paint("cet appareil", "dim") if ip == "127.0.0.1" else "")
+                        for name, (ip, port) in sorted(found.items())]))
+    elif sub == "call":
+        options, rest = _options(args[1:], flags=("--no-tls",))
+        if len(rest) < 2:
+            sys.exit("Usage : capy wifi call NOM ACTION [nom=valeur…] [--no-tls]   (ex : capy wifi call maison hello)")
+        _call(lambda: capy.wifi.call(rest[0], rest[1], tls="--no-tls" not in options, **_params(rest[2:])))
+    else:
+        sys.exit("Usage : capy wifi scan [--timeout S]   ou   capy wifi call NOM ACTION [nom=valeur…] [--no-tls]")
+
+
+# capy network call maison hello --relay mon-vps.fr:3879 --key …   /   capy network relay 3879 CLÉ
+# Relais et clé : options, sinon le capy.config.json du dossier (mode network), sinon $CAPY_RELAY / $CAPY_KEY
+def network(args):
+    import capy.network
+    sub = args[0] if args else None
+    if sub == "relay" or (sub or "").isdigit():  # capy network relay 3879 CLÉ (ou l'ancien capy network 3879 CLÉ)
+        capy.network.cli(args[1:] if sub == "relay" else args)
+    elif sub == "call":
+        options, rest = _options(args[1:], values=("--relay", "--key", "--fingerprint"))
+        if len(rest) < 2:
+            sys.exit("Usage : capy network call NOM ACTION [nom=valeur…] [--relay HÔTE:PORT] [--key CLÉ] [--fingerprint …]")
+        relay, key, fingerprint = options.get("--relay"), options.get("--key"), options.get("--fingerprint")
+        path = find(".")
+        if path and not relay:
+            try:
+                app = project(path)
+            except ValueError:
+                app = None
+            if app and app.mode == "network":
+                relay, key, fingerprint = app.relay, key or app.key, fingerprint or app.fingerprint
+        relay, key = relay or os.environ.get("CAPY_RELAY"), key or os.environ.get("CAPY_KEY")
+        if not relay:
+            sys.exit("capy : quel relais ? Ajoute --relay mon-vps.fr:3879 (ou un capy.config.json en mode network, ou $CAPY_RELAY)")
+        capy.network.use(relay, key=key, fingerprint=fingerprint)
+        _call(lambda: capy.network.call(rest[0], rest[1], **_params(rest[2:])))
+    else:
+        sys.exit("Usage : capy network call NOM ACTION [nom=valeur…] [--relay …] [--key …]   ou   capy network relay PORT [CLÉ]")
+
+
+# Lancer un fichier du projet avec le même Python, depuis le dossier du projet
+def _start(app, name, args=(), **options):
+    try:
+        path = app.file(name)
+    except KeyError as e:
+        sys.exit(e.args[0])
+    if not path.is_file():
+        sys.exit(f"capy : le fichier {name!r} ({path}) n'existe pas")
+    return subprocess.Popen([sys.executable, "-u", str(path), *args], cwd=app.folder, **options)
+
+
+# Attendre que le serveur réponde (10 s max) ; False s'il s'est arrêté avant
+def _wait_ready(app, process):
+    end = time.monotonic() + 10
+    while time.monotonic() < end:
+        if process.poll() is not None:
+            return False
+        try:
+            if app.mode == "local" and app.port:
+                socket.create_connection((app.host, app.port), timeout=0.3).close()
+                return True
+            if app.mode == "wifi":
+                import capy.wifi
+                capy.wifi._found.pop(app.name, None)
+                capy.wifi.find(app.name, timeout=0.3)
+                return True
+            if app.mode == "network" or not app.port:
+                time.sleep(2)  # Pas de moyen simple de vérifier : on laisse 2 s au serveur
+                return process.poll() is None
+        except (OSError, ConnectionError):
+            time.sleep(0.2)
+    return process.poll() is None
+
+
+# Recopier la sortie du serveur, avec "server │" devant chaque ligne
+def _relay_output(process):
+    for line in process.stdout:
+        print(f"{st.paint('server │', 'dim')} {line}", end="", flush=True)
+
+
+def run(app, args):
+    server = _start(app, "server", stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
+    threading.Thread(target=_relay_output, args=(server,), daemon=True).start()
+    try:
+        if not _wait_ready(app, server):
+            time.sleep(0.2)  # Laisser s'afficher l'erreur du serveur
+            sys.exit("capy : le serveur s'est arrêté (ou ne répond pas après 10 s)")
+        client = _start(app, "client", args)
+        code = client.wait()
+    except KeyboardInterrupt:
+        code = 130
+    finally:
+        server.terminate()
+        try:
+            server.wait(timeout=3)
+        except subprocess.TimeoutExpired:
+            server.kill()
+    sys.exit(code)
+
+
+# prog : la commande tapée (capy ou cy), pour que les suggestions la reprennent
+def main(args, prog="capy"):
+    command = args[0] if args else None
+    if command in ("-h", "--help", "help"):
+        print(usage())
+        return
+    if command in ("version", "--version", "-V"):
+        print(f"capy {version()}")
+        return
+    if command == "cli":
+        interactive()
+        return
+    if command == "domo":  # capy domo salon on
+        from .domo.__main__ import cli as domo_cli
+        domo_cli(args[1:])
+        return
+    if command == "relay":  # capy relay 3879 CLÉ
+        from .network import cli as relay_cli
+        relay_cli(args[1:])
+        return
+    if command == "network":
+        network(args[1:])
+        return
+    if command == "wifi":
+        wifi(args[1:])
+        return
+    if command == "call" and len(args) > 1 and ":" in args[1]:  # capy call localhost:4000 hello
+        call_direct(args[1:])
+        return
+    if command in ("init", "new"):
+        rest = args[1:]
+        mode = next((a for a in rest if a in MODES), "local")
+        name = next((a for a in rest if a not in MODES), None)
+        if command == "new" and not name:
+            sys.exit("Usage : capy new NOM [mode]")
+        try:
+            path = new(name, mode) / FILE_NAME if command == "new" else init(name=name, mode=mode)
+        except (FileExistsError, ValueError) as e:
+            sys.exit(str(e))
+        print(st.ok(f"Créé : {path.parent if command == 'new' else path}"), "\n")
+        print(describe(project(path)))
+        if command == "new":
+            print(f"\n{st.section('Pour l’essayer')}\n  {st.code(f'cd {name}')}\n  {st.code('cy run')}")
+        if mode == "network":
+            print(st.paint("\nPense à : export CAPY_KEY='la clé du relais' (dans ~/.zshrc), et à mettre l'adresse de ton relais", "yellow"))
+        return
+    if command is None and prog == "capy" and find(".") is None:  # capy tout seul, hors d'un projet : l'aide
+        print(usage())
+        return
+    app = _project()
+    if command is None:
+        print(describe(app))
+    elif command == "run":
+        run(app, args[1:])
+    elif command == "call":  # cy call hello nom=Izac : le serveur du projet, quel que soit son mode
+        if len(args) < 2:
+            sys.exit("Usage : cy call ACTION [nom=valeur…]   (ex : cy call hello nom=Izac)")
+        _call(lambda: app.call(args[1], **_params(args[2:])))
+    elif command == "scripts":
+        if not app.scripts:
+            print('Pas de "scripts" dans ' + FILE_NAME + ', ex : "scripts": {"test": "python3 -m unittest"}')
+        print(st.table([(st.code(name), line) for name, line in app.scripts.items()]))
+    elif command in app.scripts:
+        print(st.paint(f"> {app.scripts[command]}", "dim"), flush=True)  # Comme npm : on montre la commande lancée
+        try:
+            sys.exit(app.run_script(command, args[1:]))
+        except KeyboardInterrupt:
+            sys.exit(130)
+    elif command in app.files:
+        try:
+            sys.exit(_start(app, command, args[1:]).wait())
+        except KeyboardInterrupt:
+            sys.exit(130)
+    else:
+        names = list(app.scripts) + list(app.files) + [c for c in COMMANDS if prog == "capy" or c not in OUTSIDE]
+        close = difflib.get_close_matches(command, names, n=1)
+        if close:
+            sys.exit(f"{prog} : {command!r} inconnu, tu voulais dire {close[0]!r} ?  ({prog} {close[0]})")
+        sys.exit(f"{prog} : commande, script ou fichier {command!r} inconnu (possibles : {', '.join(names)})")
+
+
+# ============================================================
+#  MODE INTERACTIF (capy cli)
+# ============================================================
+
+HISTORY = pth.Path.home() / ".capy" / "history"
+SUBCOMMANDS = {"wifi": ["scan", "call"], "network": ["call", "relay"], "domo": ["scan", "pair", "list", "scene", "serve", "help"]}
+BUILTINS = ["help", "exit", "clear", "cd", "version"]
+
+
+# Les mots proposés par Tab : commandes, scripts et fichiers du projet, sous-commandes
+def _words(before):
+    words = before.split()
+    if not words or (len(words) == 1 and not before.endswith(" ")):
+        names = set(COMMANDS) | set(BUILTINS)
+        path = find(".")
+        if path:
+            try:
+                app = project(path)
+                names |= set(app.scripts) | set(app.files)
+            except ValueError:
+                pass
+        return sorted(names - {"cli"})
+    if words[0] in SUBCOMMANDS and (len(words) == 1 or (len(words) == 2 and not before.endswith(" "))):
+        return SUBCOMMANDS[words[0]]
+    if words[0] == "cd":
+        return sorted(p.name + "/" for p in pth.Path(".").iterdir() if p.is_dir() and not p.name.startswith("."))
+    return []
+
+
+def _setup_readline():
+    try:
+        import readline
+    except ImportError:  # Windows sans pyreadline : pas d'historique, tout le reste marche
+        return None
+
+    def complete(text, state):
+        before = readline.get_line_buffer()[:readline.get_begidx()]
+        options = [w for w in _words(before + text) if w.startswith(text)]
+        return options[state] + ("" if options[state].endswith("/") else " ") if state < len(options) else None
+
+    readline.set_completer(complete)
+    readline.set_completer_delims(" ")
+    if "libedit" in (readline.__doc__ or ""):  # macOS : libedit au lieu de GNU readline
+        readline.parse_and_bind("bind ^I rl_complete")
+    else:
+        readline.parse_and_bind("tab: complete")
+    try:
+        readline.read_history_file(HISTORY)
+    except OSError:
+        pass
+    readline.set_history_length(1000)
+    return readline
+
+
+# L'invite : "capy (mon-projet) ❯" ; les couleurs entourées de \001 \002 pour que readline compte bien la largeur
+def _prompt():
+    path = find(".")
+    name = None
+    if path:
+        try:
+            name = project(path).name
+        except ValueError:
+            name = path.parent.name
+    if not st.enabled() or not sys.stdin.isatty():
+        return ""
+    text = st.paint("capy", "mauve", bold=True) + (st.paint(f" ({name})", "dim") if name else "") + st.paint(" ❯ ", "pink", bold=True)
+    return "".join(f"\001{part}\002" if part.startswith("\033") else part for part in re.split(r"(\033\[[0-9;]*m)", text))
+
+
+# capy cli : on tape les commandes à la suite, sans retaper capy (exit ou Ctrl+D pour sortir)
+def interactive():
+    readline = _setup_readline() if sys.stdin.isatty() else None
+    if st.enabled() and sys.stdin.isatty():
+        print(st.title("capy", f"v{version()} · mode interactif"))
+        print(st.paint("  help pour l'aide · Tab pour compléter · ↑↓ l'historique · exit pour sortir\n", "dim"))
+    while True:
+        try:
+            line = input(_prompt())
+        except EOFError:
+            print()
+            break
+        except KeyboardInterrupt:
+            print()
+            continue
+        try:
+            words = shlex.split(line)
+        except ValueError as e:
+            print(st.bad(f"ligne illisible : {e}", sys.stderr), file=sys.stderr)
+            continue
+        if words[:1] in (["capy"], ["cy"]):  # L'habitude de taper capy devant
+            words = words[1:]
+        if not words:
+            continue
+        if words[0] in ("exit", "quit", "q"):
+            break
+        if words[0] == "clear":
+            print("\033[2J\033[H", end="")
+            continue
+        if words[0] == "cd":
+            try:
+                os.chdir(os.path.expanduser(words[1] if len(words) > 1 else "~"))
+            except OSError as e:
+                print(st.bad(str(e), sys.stderr), file=sys.stderr)
+            continue
+        if words[0] == "cli":
+            continue
+        try:
+            main(words)
+        except SystemExit as e:
+            _show_error(e)
+        except KeyboardInterrupt:
+            print()
+    if readline:
+        try:
+            HISTORY.parent.mkdir(exist_ok=True)
+            readline.write_history_file(HISTORY)
+        except OSError:
+            pass
+
+
+# Une erreur (sys.exit("message")) : ✗ rouge devant, sur la sortie d'erreur
+def _show_error(error):
+    if isinstance(error.code, str):
+        first, *rest = error.code.split("\n")
+        print("\n".join([st.bad(first, sys.stderr), *rest]), file=sys.stderr)
+
+
+def _run(args, prog):
+    try:
+        main(args, prog)
+    except SystemExit as e:
+        _show_error(e)
+        raise SystemExit(1 if isinstance(e.code, str) else e.code) from None
+    except KeyboardInterrupt:
+        print()
+        raise SystemExit(130) from None
+
+
+# La commande cy : seulement les commandes d'un projet (et cy cli)
+def cli():
+    args = sys.argv[1:]
+    if args[:1] in [[c] for c in OUTSIDE]:
+        _show_error(SystemExit(f"cy sert dans un projet capy ; pour ça, c'est la commande capy : capy {' '.join(args)}"))
+        raise SystemExit(1)
+    _run(args, "cy")
+
+
+# La commande capy (et python3 -m capy) : tout
+def capy_cli():
+    _run(sys.argv[1:], "capy")
+
+
+if __name__ == "__main__":
+    capy_cli()

{capyy-0.5.2 → capyy-0.5.4}/capy/_project.py

@@ -46,7 +46,7 @@ FIELDS = {
 
 EXAMPLE = {"name": "mon-projet", "mode": "local", "host": "localhost", "port": 4000, "tls": True,
            "files": {"server": "server.py", "client": "client.py"}}
-COMMANDS = ("init", "new", "run", "scripts", "help", "domo", "relay")  # Mots réservés de cy / capy (pas des noms de fichiers ni de scripts)
+COMMANDS = ("init", "new", "run", "scripts", "help", "call", "cli", "version", "domo", "relay", "wifi", "network")  # Mots réservés de cy / capy (pas des noms de fichiers ni de scripts)
 
 
 # Dossier du script lancé (comme simplesuit.json) ; sans script (python3 -c, REPL) -> dossier actuel

capyy-0.5.4/capy/_style.py

@@ -0,0 +1,112 @@
+# capy : le style des commandes capy et cy (couleurs, icônes, JSON coloré), sans dépendance
+# Les couleurs se coupent toutes seules si la sortie n'est pas un terminal (fichier, | jq…) ou avec NO_COLOR=1
+
+import json as jsonlib
+import os
+import re
+import sys
+
+# Couleurs Catppuccin Mocha (comme le thème du terminal), en RGB 24 bits
+PALETTE = {
+    "text": (205, 214, 244), "dim": (127, 132, 156), "blue": (137, 180, 250), "green": (166, 227, 161),
+    "red": (243, 139, 168), "peach": (250, 179, 135), "yellow": (249, 226, 175), "mauve": (203, 166, 247),
+    "teal": (148, 226, 213), "pink": (245, 194, 231),
+}
+RESET = "\033[0m"
+
+
+# Couleurs sur cette sortie ? (terminal, et pas de NO_COLOR)
+def enabled(stream=None):
+    stream = stream or sys.stdout
+    return hasattr(stream, "isatty") and stream.isatty() and not os.environ.get("NO_COLOR")
+
+
+# Colorer un texte : paint("ok", "green", bold=True)
+def paint(text, color=None, bold=False, dim=False, stream=None):
+    if not enabled(stream):
+        return str(text)
+    codes = ""
+    if color:
+        codes += "\033[38;2;{};{};{}m".format(*PALETTE[color])
+    if bold:
+        codes += "\033[1m"
+    if dim:
+        codes += "\033[2m"
+    return f"{codes}{text}{RESET}"
+
+
+# Enlever les couleurs (pour mesurer la vraie largeur d'un texte)
+def strip(text):
+    return re.sub(r"\033\[[0-9;]*m", "", text)
+
+
+# Raccourcis
+def ok(text):
+    return f"{paint('✓', 'green', bold=True)} {text}"
+
+
+def bad(text, stream=None):
+    return f"{paint('✗', 'red', bold=True, stream=stream)} {text}"
+
+
+def title(text, extra=""):
+    return f"{paint('◆', 'mauve', bold=True)} {paint(text, bold=True)}" + (f"  {paint(extra, 'dim')}" if extra else "")
+
+
+def section(text):
+    return paint(text, "blue", bold=True)
+
+
+def code(text):
+    return paint(text, "teal")
+
+
+# Un petit carré de la couleur donnée ("#FF7800") : l'aperçu d'une lampe
+def swatch(hexa, stream=None):
+    if not enabled(stream) or not hexa:
+        return ""
+    r, g, b = (int(hexa.lstrip("#")[i:i + 2], 16) for i in (0, 2, 4))
+    return f"\033[38;2;{r};{g};{b}m██{RESET}"
+
+
+# Un tableau aligné : [(colonne1, colonne2, …)] ; les couleurs ne gênent pas l'alignement
+def table(rows, indent=2, gap=3):
+    rows = [[str(c) for c in row] for row in rows]
+    if not rows:
+        return ""
+    widths = [max(len(strip(row[i])) for row in rows if i < len(row)) for i in range(max(len(r) for r in rows))]
+    lines = []
+    for row in rows:
+        cells = [cell + " " * (widths[i] - len(strip(cell))) if i < len(row) - 1 else cell for i, cell in enumerate(row)]
+        lines.append(" " * indent + (" " * gap).join(cells).rstrip())
+    return "\n".join(lines)
+
+
+# Du JSON indenté et coloré (clés en bleu, textes en vert, nombres en orange…), JSON pur sans couleurs
+def pretty(data, stream=None):
+    if not enabled(stream):
+        return jsonlib.dumps(data, indent=2, ensure_ascii=False)
+    return _pretty(data, 0)
+
+
+def _pretty(value, level):
+    pad, end = "  " * (level + 1), "  " * level
+    punct = lambda t: paint(t, "dim")
+    if isinstance(value, dict):
+        if not value:
+            return punct("{}")
+        items = [f"{pad}{paint(jsonlib.dumps(str(k), ensure_ascii=False), 'blue')}{punct(':')} {_pretty(v, level + 1)}"
+                 for k, v in value.items()]
+        return punct("{") + "\n" + (punct(",") + "\n").join(items) + "\n" + end + punct("}")
+    if isinstance(value, list):
+        if not value:
+            return punct("[]")
+        items = [pad + _pretty(v, level + 1) for v in value]
+        return punct("[") + "\n" + (punct(",") + "\n").join(items) + "\n" + end + punct("]")
+    if value is None:
+        return paint("null", "red")
+    if isinstance(value, bool):
+        return paint("true" if value else "false", "mauve")
+    if isinstance(value, (int, float)):
+        return paint(jsonlib.dumps(value), "peach")
+    return paint(jsonlib.dumps(str(value), ensure_ascii=False), "green")

{capyy-0.5.2 → capyy-0.5.4}/capy/_tls.py

@@ -12,6 +12,7 @@ import pathlib as pth
 import socket
 import ssl
 import subprocess
+import sys
 import threading
 
 CAPY_DIR = pth.Path.home() / ".capy"
@@ -119,7 +120,8 @@ def check(label, seen, pinned=None, who="capy", kind="serveur", local=False):
             CAPY_DIR.mkdir(exist_ok=True)
             known[label] = seen
             KNOWN_FILE.write_text(json.dumps(known, indent=4))
-            print(f"{who} : nouveau {kind} {label}, empreinte retenue {seen}", flush=True)
+            # Sur stderr : la sortie normale reste propre (ex : capy call … | jq)
+            print(f"{who} : nouveau {kind} {label}, empreinte retenue {seen}", file=sys.stderr, flush=True)
             return
     if not hmac.compare_digest(known[label], seen):
         raise SecurityError(

{capyy-0.5.2 → capyy-0.5.4}/capy/domo/__main__.py

@@ -16,6 +16,7 @@ import sys
 import time
 
 import capy
+from capy import _style as st
 
 from . import FILE_NAME, WHITES, Home, Remote, _hue, find, serve, to_kelvin, to_rgb
 
@@ -51,18 +52,21 @@ def parse(words):
     return changes
 
 
+# Une ligne d'état : "● salon   allumé · 30 % · ██ #FF7800" (le carré est de la couleur de la lampe)
 def show_state(name, state):
+    label = st.code(f"{name:<18}")
     if not state.get("reachable", True):
-        return f"  {name:<18} injoignable"
-    parts = ["allumé" if state["on"] else "éteint"]
-    if state["on"]:
-        if state.get("brightness") is not None:
-            parts.append(f"{state['brightness']} %")
-        if state.get("color"):
-            parts.append(state["color"])
-        if state.get("kelvin"):
-            parts.append(f"{state['kelvin']} K")
-    return f"  {name:<18} {' · '.join(parts)}"
+        return f"  {st.paint('✗', 'red')} {label} {st.paint('injoignable', 'red')}"
+    if not state["on"]:
+        return f"  {st.paint('○', 'dim')} {label} {st.paint('éteint', 'dim')}"
+    parts = ["allumé"]
+    if state.get("brightness") is not None:
+        parts.append(f"{state['brightness']} %")
+    if state.get("color"):
+        parts.append(f"{st.swatch(state['color'])} {state['color']}".strip())
+    if state.get("kelvin"):
+        parts.append(f"{state['kelvin']} K")
+    return f"  {st.paint('●', 'yellow')} {label} {' · '.join(parts)}"
 
 
 def main(args):
@@ -81,14 +85,14 @@ def main(args):
     command, rest = args[0], args[1:]
 
     if command == "scan" and not remote:
-        print("Recherche sur le réseau…")
+        print(st.paint("  Recherche sur le réseau…", "dim"), flush=True)
         found = home.scan()
         for device in found:
-            print(f"  + {device.name:<18} {device.brand:<14} {device.host or device.id}")
+            print(f"  {st.paint('+', 'green', bold=True)} {st.code(f'{device.name:<18}')} {device.brand:<14} {st.paint(device.host or device.id, 'dim')}")
         for hint in home.hints:
-            print("  !", hint)
+            print(f"  {st.paint('!', 'yellow', bold=True)} {hint}")
         if found:
-            print(f"{len(found)} appareil(s) ajouté(s) dans {home.save()}  (renomme-les dans ce fichier si tu veux)")
+            print(st.ok(f"{len(found)} appareil(s) ajouté(s) dans {home.save()}") + st.paint("  (renomme-les dans ce fichier si tu veux)", "dim"))
         elif not home.hints:
             print("Rien de nouveau trouvé (même réseau ? appareils allumés ?)")
 
@@ -120,8 +124,8 @@ def main(args):
         else:
             sys.exit("Usage : capy domo pair hue [IP]  ou  pair homeassistant URL")
         for device in added:
-            print(f"  + {device.name:<18} {device.brand}")
-        print(f"{len(added)} appareil(s) ajouté(s) dans {home.save()}")
+            print(f"  {st.paint('+', 'green', bold=True)} {st.code(f'{device.name:<18}')} {device.brand}")
+        print(st.ok(f"{len(added)} appareil(s) ajouté(s) dans {home.save()}"))
 
     elif command == "list":
         if remote:
@@ -131,21 +135,20 @@ def main(args):
         else:
             names, groups, scenes = list(home.devices), home.groups, list(home.scenes)
             states = home.all().state() if home.devices else {}
-        print("Appareils :" if names else "Aucun appareil : lance  capy domo scan")
+        print(st.section("Appareils") if names else "Aucun appareil : lance  " + st.code("capy domo scan"))
         for name in names:
             print(show_state(name, states.get(name, {"reachable": False})))
         if groups:
-            print("Groupes :")
-            for name, members in groups.items():
-                print(f"  {name:<18} {', '.join(members)}")
+            print("\n" + st.section("Groupes"))
+            print(st.table([(st.code(name), st.paint(", ".join(members), "dim")) for name, members in groups.items()]))
         if scenes:
-            print("Scènes :", ", ".join(scenes))
+            print("\n" + st.section("Scènes") + "  " + "  ".join(st.code(s) for s in scenes))
 
     elif command == "scene":
         if not rest:
             sys.exit("Usage : capy domo scene NOM")
         home.scene(rest[0])
-        print(f"Scène {rest[0]!r} lancée")
+        print(st.ok(f"Scène {rest[0]!r} lancée"))
 
     elif command == "serve" and not remote:
         print("Maison pilotable à distance (actions domo.*), Ctrl+C pour arrêter")
@@ -167,7 +170,7 @@ def main(args):
             target.toggle()
         if changes:
             target.set(**changes)
-        print(f"{command} : ok")
+        print(st.ok(f"{command} : {' · '.join(rest)}"))
 
 
 # Point d'entrée de capy domo

{capyy-0.5.2 → capyy-0.5.4}/capyy.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: capyy
-Version: 0.5.2
+Version: 0.5.4
 Summary: Easy, encrypted networking for Python: programs that talk (local, Wi-Fi, internet), home automation, and projects run with cy
 Author: Izac
 License-Expression: MIT
@@ -101,6 +101,22 @@ app.call("hello", nom="Izac")   # client side
 `mode` can be `local`, `wifi` or `network` (with `relay`, `key`, `fingerprint`). Strings starting with `$` are read
 from environment variables, e.g. `"key": "$CAPY_KEY"`. Inside a project, the `cy` command runs its `scripts` like `npm run` (`cy test`, `cy start`) and its files (`cy server`); create a project with `capy new`.
 
+## From the terminal
+
+```bash
+capy call localhost:4000 hello nom=Izac        # any capy server (add --no-tls for a plain one)
+capy wifi scan                                 # capy.wifi servers on your network
+capy wifi call home temperature
+capy network call home test --relay my-vps.example:3879 --key "$CAPY_KEY"
+cy call hello nom=Izac                         # inside a project: uses capy.config.json
+```
+
+`capy cli` opens an interactive prompt (history, Tab completion, `cd` between projects). Output is colored in a
+terminal and plain text / JSON in a pipe (set `NO_COLOR=1` to disable colors).
+
+Parameters are `name=value`; numbers, `true`/`false` and lists are parsed (`age=14` sends the number 14).
+The answer is printed as JSON; the exit code is 1 when the server answers `{"erreur": ...}`.
+
 ## Encryption (TLS)
 
 Everything is encrypted by default, with nothing to configure.

{capyy-0.5.2 → capyy-0.5.4}/capyy.egg-info/SOURCES.txt

@@ -4,6 +4,7 @@ pyproject.toml
 capy/__init__.py
 capy/__main__.py
 capy/_project.py
+capy/_style.py
 capy/_tls.py
 capy/network.py
 capy/wifi.py

{capyy-0.5.2 → capyy-0.5.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "capyy"
-version = "0.5.2"
+version = "0.5.4"
 description = "Easy, encrypted networking for Python: programs that talk (local, Wi-Fi, internet), home automation, and projects run with cy"
 readme = "README.md"
 requires-python = ">=3.9"

{capyy-0.5.2 → capyy-0.5.4}/tests/test_capy.py

@@ -357,5 +357,77 @@ class TestProject(unittest.TestCase):
         self.assertEqual(json.loads(path.read_text())["key"], "$CAPY_KEY")
 
 
+# Les commandes capy / cy, lancées pour de vrai (dossier personnel temporaire : ~/.capy n'est pas touché)
+class TestCommandLine(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.home = tempfile.TemporaryDirectory()
+        cls.server = start(demo_server(capy.Server(0, tls=False)))
+        cls.relay_port = free_port()
+        threading.Thread(target=capy.network.Relay(cls.relay_port, key="cle").run, daemon=True).start()
+        time.sleep(0.5)
+        capy.network.use(f"127.0.0.1:{cls.relay_port}", key="cle")
+        start(demo_server(capy.network.Server("cli")), wait=lambda s: True)
+        time.sleep(1)
+
+    @classmethod
+    def tearDownClass(cls):
+        cls.home.cleanup()
+
+    def run_capy(self, *args, cwd=None):
+        import subprocess
+        import sys
+        # Autre HOME : Python ne voit plus les paquets installés pour l'utilisateur, on lui montre capy
+        env = {**os.environ, "HOME": self.home.name, "PYTHONPATH": str(pathlib.Path(__file__).resolve().parent.parent)}
+        return subprocess.run([sys.executable, "-m", "capy", *args], cwd=cwd or self.home.name, env=env,
+                              capture_output=True, text=True, timeout=30)
+
+    def test_call(self):
+        result = self.run_capy("call", f"localhost:{self.server.port}", "hello", "name=Zoé", "--no-tls")
+        self.assertEqual((result.returncode, json.loads(result.stdout)), (0, {"message": "Bonjour Zoé"}))
+        result = self.run_capy("call", f"localhost:{self.server.port}", "divide", "a=6", "b=3", "--no-tls")
+        self.assertEqual(json.loads(result.stdout), {"result": 2.0})  # "6" et "3" compris comme des nombres
+        result = self.run_capy("call", f"localhost:{self.server.port}", "nope", "--no-tls")
+        self.assertEqual(result.returncode, 1)  # Réponse {"erreur": ...} -> code 1
+        self.assertIn("nom=valeur", self.run_capy("call", f"localhost:{self.server.port}", "hello", "name", "--no-tls").stderr)
+
+    def test_project_call(self):
+        folder = pathlib.Path(self.home.name) / "projet"
+        folder.mkdir(exist_ok=True)
+        (folder / "capy.config.json").write_text(json.dumps({"port": self.server.port, "tls": False}))
+        result = self.run_capy("call", "hello", "name=Projet", cwd=folder)
+        self.assertEqual(json.loads(result.stdout), {"message": "Bonjour Projet"})
+
+    def test_network_call(self):
+        result = self.run_capy("network", "call", "cli", "hello", "name=Léa", "--relay", f"127.0.0.1:{self.relay_port}", "--key", "cle")
+        self.assertEqual(json.loads(result.stdout), {"message": "Bonjour Léa"})
+        self.assertIn("quel relais", self.run_capy("network", "call", "cli", "hello").stderr)
+
+    def test_interactive(self):
+        import subprocess
+        import sys
+        env = {**os.environ, "HOME": self.home.name, "PYTHONPATH": str(pathlib.Path(__file__).resolve().parent.parent)}
+        lines = f"call localhost:{self.server.port} hello name=Cli --no-tls\ncapy version\nfaute\ncd /\nexit\n"
+        result = subprocess.run([sys.executable, "-m", "capy", "cli"], input=lines, cwd=self.home.name, env=env,
+                                capture_output=True, text=True, timeout=30)
+        self.assertIn('"message": "Bonjour Cli"', result.stdout)  # La commande a marché
+        self.assertIn("capy ", result.stdout)                      # "capy version" (capy devant est accepté)
+        self.assertIn("pas un projet capy", result.stderr)         # Une erreur n'arrête pas le mode interactif
+        self.assertEqual(result.returncode, 0)
+        self.assertFalse((pathlib.Path(self.home.name) / ".capy" / "history").exists())  # Pas un vrai terminal : pas d'historique
+
+    def test_plain_output_when_piped(self):
+        result = self.run_capy("help")
+        self.assertNotIn("\033[", result.stdout)  # Pas de couleurs hors d'un terminal (| jq, fichiers…)
+        self.assertIn("capy cli", result.stdout)
+
+    def test_reserved_script_names(self):
+        for name in ("call", "wifi", "network", "cli", "version"):
+            with self.assertRaisesRegex(ValueError, "nom d'une commande"):
+                path = pathlib.Path(self.home.name) / "capy.config.json"
+                path.write_text(json.dumps({"port": 1, "scripts": {name: "echo"}}))
+                capy.project(path)
+
+
 if __name__ == "__main__":
     unittest.main()

{capyy-0.5.2 → capyy-0.5.4}/tests/test_domo.py

@@ -345,7 +345,10 @@ class TestBrands(unittest.TestCase):
         self.assertFalse(found["switch.radiateur"].state()["on"])
 
     def test_unreachable(self):
-        lamp = domo._wiz.WizLight("fantome", "127.0.0.1", port=free_port(socket.SOCK_DGRAM))
+        silent = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)  # Un port gardé, qui ne répond jamais
+        silent.bind(("127.0.0.1", 0))
+        self.addCleanup(silent.close)
+        lamp = domo._wiz.WizLight("fantome", "127.0.0.1", port=silent.getsockname()[1])
         self.assertEqual(lamp.state()["reachable"], False)
         with self.assertRaisesRegex(ConnectionError, "'fantome' \\(wiz\\) ne répond pas"):
             lamp.on()

capyy-0.5.2/capy/__main__.py

@@ -1,187 +0,0 @@
-# Deux commandes, installées avec capy :
-#
-# cy : DANS un projet capy (un dossier avec capy.config.json, ou en dessous)
-#   cy                          -> montre le projet (nom, mode, adresse, fichiers, scripts…)
-#   cy NOM [args…]              -> lance le script NOM de "scripts" (comme npm run)
-#   cy scripts                  -> liste les scripts
-#   cy server / cy client       -> lance un fichier de "files"
-#   cy run                      -> lance le serveur en fond, puis le client, puis arrête le serveur
-#
-# capy : tout le reste (et tout ce que fait cy)
-#   capy new NOM [mode]         -> crée un dossier NOM avec capy.config.json, server.py, client.py
-#   capy init [nom] [mode]      -> crée juste capy.config.json ici
-#   capy domo …                 -> la domotique (capy domo help)
-#   capy relay PORT [CLÉ]       -> lance un relais capy.network (sur le VPS)
-#   mode : local (par défaut), wifi ou network
-#   python3 -m capy = capy (si la commande n'est pas dans le PATH)
-
-import difflib
-import socket
-import subprocess
-import sys
-import threading
-import time
-
-from ._project import COMMANDS, FILE_NAME, MODES, find, init, new, project
-
-USAGE = f"""Dans un projet capy ({FILE_NAME}) :
-  cy                     montre le projet
-  cy NOM [args…]         lance le script NOM de "scripts" (comme npm run)
-  cy scripts             liste les scripts
-  cy server / client     lance un fichier de "files"
-  cy run                 serveur en fond + client, puis arrête le serveur
-Partout :
-  capy new NOM [mode]    crée un projet complet (config, server.py, client.py)
-  capy init [nom] [mode] crée juste {FILE_NAME} ici
-  capy domo …            la domotique (capy domo help)
-  capy relay PORT [CLÉ]  lance un relais capy.network
-  modes : {", ".join(MODES)}"""
-
-
-# Le projet du dossier actuel (ou au-dessus), sinon on explique quoi faire
-def _project():
-    path = find(".")
-    if path is None:
-        sys.exit(f"Pas de {FILE_NAME} ici ni au-dessus : ce dossier n'est pas un projet capy.\n"
-                 f"  Crée un projet : capy new mon-projet\n"
-                 f"  ou juste le fichier : capy init")
-    try:
-        return project(path)
-    except ValueError as e:
-        sys.exit(str(e))
-
-
-# Lancer un fichier du projet avec le même Python, depuis le dossier du projet
-def _start(app, name, args=(), **options):
-    try:
-        path = app.file(name)
-    except KeyError as e:
-        sys.exit(e.args[0])
-    if not path.is_file():
-        sys.exit(f"capy : le fichier {name!r} ({path}) n'existe pas")
-    return subprocess.Popen([sys.executable, "-u", str(path), *args], cwd=app.folder, **options)
-
-
-# Attendre que le serveur réponde (10 s max) ; False s'il s'est arrêté avant
-def _wait_ready(app, process):
-    end = time.monotonic() + 10
-    while time.monotonic() < end:
-        if process.poll() is not None:
-            return False
-        try:
-            if app.mode == "local" and app.port:
-                socket.create_connection((app.host, app.port), timeout=0.3).close()
-                return True
-            if app.mode == "wifi":
-                import capy.wifi
-                capy.wifi._found.pop(app.name, None)
-                capy.wifi.find(app.name, timeout=0.3)
-                return True
-            if app.mode == "network" or not app.port:
-                time.sleep(2)  # Pas de moyen simple de vérifier : on laisse 2 s au serveur
-                return process.poll() is None
-        except (OSError, ConnectionError):
-            time.sleep(0.2)
-    return process.poll() is None
-
-
-# Recopier la sortie du serveur, avec "server │" devant chaque ligne
-def _relay_output(process):
-    for line in process.stdout:
-        print(f"\033[2mserver │\033[0m {line}", end="", flush=True)
-
-
-def run(app, args):
-    server = _start(app, "server", stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
-    threading.Thread(target=_relay_output, args=(server,), daemon=True).start()
-    try:
-        if not _wait_ready(app, server):
-            time.sleep(0.2)  # Laisser s'afficher l'erreur du serveur
-            sys.exit(f"capy : le serveur s'est arrêté (ou ne répond pas après 10 s)")
-        client = _start(app, "client", args)
-        code = client.wait()
-    except KeyboardInterrupt:
-        code = 130
-    finally:
-        server.terminate()
-        try:
-            server.wait(timeout=3)
-        except subprocess.TimeoutExpired:
-            server.kill()
-    sys.exit(code)
-
-
-def main(args):
-    command = args[0] if args else None
-    if command in ("-h", "--help", "help"):
-        print(USAGE)
-        return
-    if command == "domo":  # capy domo salon on
-        from .domo.__main__ import cli as domo_cli
-        domo_cli(args[1:])
-        return
-    if command in ("relay", "network"):  # capy relay 3879 CLÉ
-        from .network import cli as relay_cli
-        relay_cli(args[1:])
-        return
-    if command in ("init", "new"):
-        rest = args[1:]
-        mode = next((a for a in rest if a in MODES), "local")
-        name = next((a for a in rest if a not in MODES), None)
-        if command == "new" and not name:
-            sys.exit("Usage : capy new NOM [mode]")
-        try:
-            path = new(name, mode) / FILE_NAME if command == "new" else init(name=name, mode=mode)
-        except (FileExistsError, ValueError) as e:
-            sys.exit(str(e))
-        print(f"Créé : {path.parent if command == 'new' else path}")
-        print(project(path).describe())
-        if command == "new":
-            print(f"\nPour l'essayer :\n  cd {name}\n  cy run")
-        if mode == "network":
-            print("Pense à : export CAPY_KEY='la clé du relais' (dans ~/.zshrc), et à mettre l'adresse de ton relais")
-        return
-    app = _project()
-    if command is None:
-        print(app.describe())
-    elif command == "run":
-        run(app, args[1:])
-    elif command == "scripts":
-        if not app.scripts:
-            print('Pas de "scripts" dans ' + FILE_NAME + ', ex : "scripts": {"test": "python3 -m unittest"}')
-        for name, line in app.scripts.items():
-            print(f"  {name:<12} {line}")
-    elif command in app.scripts:
-        print(f"\033[2m> {app.scripts[command]}\033[0m", flush=True)  # Comme npm : on montre la commande lancée
-        try:
-            sys.exit(app.run_script(command, args[1:]))
-        except KeyboardInterrupt:
-            sys.exit(130)
-    elif command in app.files:
-        try:
-            sys.exit(_start(app, command, args[1:]).wait())
-        except KeyboardInterrupt:
-            sys.exit(130)
-    else:
-        names = list(app.scripts) + list(app.files) + list(COMMANDS)
-        close = difflib.get_close_matches(command, names, n=1)
-        if close:
-            sys.exit(f"capy : {command!r} inconnu, tu voulais dire {close[0]!r} ?  (cy {close[0]})")
-        sys.exit(f"capy : commande, script ou fichier {command!r} inconnu (possibles : {', '.join(names)})\n\n{USAGE}")
-
-
-# La commande cy : seulement les commandes d'un projet
-def cli():
-    args = sys.argv[1:]
-    if args[:1] in (["new"], ["init"], ["domo"], ["relay"], ["network"]):
-        sys.exit(f"cy sert dans un projet capy ; pour ça, c'est la commande capy : capy {' '.join(args)}")
-    main(args)
-
-
-# La commande capy (et python3 -m capy) : tout
-def capy_cli():
-    main(sys.argv[1:])
-
-
-if __name__ == "__main__":
-    capy_cli()