`serve` affiche une URL. Ouvrez-la dans n'importe quel navigateur et vous obtenez un terminal, un explorateur de fichiers et un proxy vers le réseau de cette machine — ou accédez à la même machine depuis un autre terminal avec `bitbang connect <url>`, qui ajoute la redirection de port (`-L`) et la copie de fichiers (`bitbang cp`). La connexion est chiffrée de bout en bout et pair-à-pair ; le serveur `bitba.ng` présente les deux extrémités, puis s'efface.

`bitbang` est un binaire Go statique unique. Il fait partie du [projet BitBang](https://github.com/richlegrand/bitbang) ; ce [livre blanc](https://github.com/richlegrand/bitbang/blob/main/whitepaper.md) couvre la conception en profondeur.

## Comparaison

|                                | ngrok                  | Tailscale                      | `bitbang`           |
| ------------------------------ | ---------------------- | ------------------------------ | ------------------- |
| Configuration avant la première utilisation | Compte + jeton d'authentification | Compte + connexion sur chaque appareil | **Exécutez une seule commande** |
| Pour partager quelque chose, vous exécutez | un serveur web, plus ngrok | leur client sur les deux machines | **`bitbang serve`** |
| Ce qu'un navigateur à l'autre extrémité obtient | le serveur web que vous exécutiez déjà | rien — il a besoin de leur client | **un terminal, un explorateur de fichiers et des applications web sur le réseau distant** |
| Chemin des données              | leurs serveurs          | P2P (repli par relais)           | **P2P (repli par relais)** |
| Chiffré de bout en bout           | Pas par défaut         | Oui                            | **Oui**             |

## Recettes rapides

**Accéder à un service à la maison**

- [Montez votre NAS domestique depuis n'importe où (SMB)](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#mount-your-home-nas-from-anywhere-smb)
- [Regardez votre bibliothèque multimédia depuis n'importe où (Jellyfin)](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#watch-your-media-library-from-anywhere-jellyfin)
- [Utilisez votre propre LLM depuis n'importe où (Ollama, Open WebUI)](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#use-your-own-llm-from-anywhere-ollama-open-webui)
- [Vérifiez vos caméras de sécurité (Frigate)](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#check-your-security-cameras-frigate)
- [Accédez à votre domotique sans l'exposer (Home Assistant)](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#reach-your-home-automation-without-exposing-it-home-assistant)
- [Imprimez sur votre imprimante domestique (IPP, CUPS)](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#print-to-your-home-printer-ipp-cups)

**Accéder à une machine**

- [Obtenez un shell sur une machine derrière un NAT](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#get-a-shell-on-a-machine-behind-nat)
- [Obtenez un shell depuis votre téléphone](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#get-a-shell-from-your-phone)
- [Bureau à distance sur une machine Windows (RDP)](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#remote-desktop-into-a-windows-machine-rdp)
- [Accédez à un bureau Linux ou Mac (VNC)](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#reach-a-linux-or-mac-desktop-vnc)
- [SSH vers une machine sans port ouvert (OpenSSH)](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#ssh-to-a-machine-with-no-open-port-openssh)
- [Configurez un Raspberry Pi sans écran](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#set-up-a-headless-raspberry-pi)

**Partager avec quelqu'un d'autre**

Partager consiste simplement à donner à quelqu'un une URL unique ou un code QR qui lui donne accès. Les autorisations peuvent être personnalisées et définies pour expirer en quelques minutes, heures, etc.

- [Partagez des fichiers sans les téléverser nulle part](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#share-files-without-uploading-them-anywhere)
- [Montrez votre projet à quelqu'un](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#show-someone-your-project)
- [Donnez un accès qui expire](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#give-someone-access-that-expires)
- [Vérifiez votre session d'agent depuis votre téléphone (Claude Code, tmux)](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#check-your-agent-session-from-your-phone-claude-code-tmux)
- [Réparez le routeur de quelqu'un d'autre](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#fix-someone-elses-router)

**Développement et appareils**

- [Accédez à une base de données depuis votre machine de développement (Postgres, MySQL)](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#reach-a-database-from-your-dev-machine-postgres-mysql)
- [Synchronisez des appareils qui ne peuvent pas se trouver (Syncthing)](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#sync-devices-that-cannot-find-each-other-syncthing)
- [Regardez un robot depuis un navigateur (ROS, Foxglove)](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#watch-a-robot-from-a-browser-ros-foxglove)

**Techniques**

- [Ce qu'un écouteur de redirection expose](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#what-a-forwarding-listener-exposes)
- [Laissez d'autres machines de votre LAN utiliser une redirection](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#let-other-machines-on-your-lan-use-a-forward)
- [Connu pour ne pas fonctionner](https://github.com/richlegrand/bitbang/blob/main/cookbook.md#known-not-to-work)

## Utilisation de `bitbang`

Chaque connexion a deux extrémités : un **écouteur** (`bitbang serve`, exécuté sur la machine à atteindre) et un **connecteur** (un navigateur, ou la CLI `bitbang`, sur la machine qui effectue la connexion). Une URL d'écouteur sert les deux types de connecteurs.

### L'écouteur : `bitbang serve````
bitbang serve                    # everything: shell + proxy + files + forward
bitbang serve shell              # just a terminal
bitbang serve files ~/share      # just a directory (-files-upload to allow uploads)
bitbang serve proxy localhost:8080       # just one web app, straight at the URL
bitbang serve proxy a.lan:80,b.lan:80    # ...or several, chosen in the browser
bitbang serve forward 127.0.0.1:22       # just TCP, for `connect -L`

bitbang serve shell files ~/share proxy nas.lan:8096   # any combination

La commande retourne après la publication, donc `Ctrl-Z`, `bitbang share`, `fg`
fonctionne pour une tâche déjà en cours. L'hébergement nécessite tmux 3.2+ sur Unix ou
WSL. Les clients Windows natifs peuvent ouvrir les URL mais ne peuvent pas héberger un partage.

Par défaut, la commande affiche deux URL bearer :

- L'**URL de contrôle** peut saisir avec la même autorité que le clavier local.
  Un seul contrôleur peut se connecter à la fois.
- L'**URL de visualisation** est en lecture seule. L'entrée est supprimée avant d'atteindre tmux, et
  jusqu'à `--max-viewers` spectateurs peuvent se connecter à la fois (16 par défaut).

`--read-only` omet entièrement l'identifiant de contrôle. Les limites de spectateurs et de contrôleurs
sont maintenues pendant toute la durée de vie de chaque connexion, même avant l'ouverture d'un shell.

Les partages s'exécutent jusqu'à arrêt par défaut ; `--ttl` définit une durée de vie (par ex. `--ttl 1h`).
Les URL de partage sont éphémères et ne sont jamais enregistrées dans `devices.json`. `share stop`,
l'expiration du TTL, ou la suppression de la session source déconnecte les pairs distants sans
arrêter la session source.

Réexécuter `bitbang share` réaffiche les URL du partage en cours. Si vous
passez un drapeau qui entre en conflit avec ce qui est en cours (par ex. `--read-only`
contre un partage qui possède une URL de contrôle), il le signale plutôt que de
renvoyer les anciennes URL ; `bitbang share rotate` remplace le partage
par un qui utilise les nouveaux drapeaux.

Un processus en arrière-plan s'exécute dans une session de gestion tmux détachée `_bbshare_*`,
donc il n'y a ni démon ni fichier PID à gérer.

Le partage ne modifie aucune option tmux. Avec la valeur par défaut `window-size latest` de tmux, la
fenêtre suit le client lecture-écriture actif ; un spectateur isolé fournit toujours la
seule taille disponible. Si `window-size` a été remplacé, `share` le signale
mais ne modifie pas la configuration de l'utilisateur.

### Distribution d'un accès limité : `bitbang link`

Un écouteur, une URL, et autant de **liens d'accès** que nécessaire. Chacun est un
code distinct sur cette même URL, accordant un sous-ensemble de ce que l'écouteur offre
et expirant éventuellement à un moment fixe :```
bitbang link edit                # add entries in $EDITOR
bitbang link ls                  # what you have handed out
bitbang link rm <label>          # revoke one
bitbang link qr <label>          # its URL and QR code

I need the actual content of chunk 11 to translate it. Please provide the Markdown text you'd like translated from English to French.```
  0) owner  files forward proxy shell
     https://bitba.ng/8ach_I7oQk2vBb9xYzT0Lw#_vtQ0JCPe7s
  1) ana    files  expires in 6d
     https://bitba.ng/8ach_I7oQk2vBb9xYzT0Lw#T-Ty_HhvLfY
  2) ben    files /srv/photos
     https://bitba.ng/8ach_I7oQk2vBb9xYzT0Lw#L6La8OzBO74
  3) dev    forward 127.0.0.1:5432 shell
     https://bitba.ng/8ach_I7oQk2vBb9xYzT0Lw#8kmI3LYzB7E

Le listener transmet la configuration au serveur de signalisation lors de l'enregistrement, et le serveur
la donne à quiconque se connecte — les deux extrémités utilisent donc votre relais et le nôtre n'est jamais impliqué.
N'importe quel coturn, ou un fournisseur hébergé comme Cloudflare ou Twilio, fonctionne.

Le fichier est au format JSON, sous l'une de ces trois formes que votre fournisseur vous a remises :```json
[{"urls": ["turn:turn.example.net:3478"], "username": "user", "credential": "pass"}]

## 📦 Installation

### Option 1: Install via pip

```bash
pip install kitploit

git clone https://github.com/kitploit/kitploit.git
cd kitploit
pip install -r requirements.txt
python setup.py install

docker pull kitploit/kitploit
docker run -it --rm kitploit/kitploit

kitploit --help

kitploit search nmap

kitploit info metasploit

# Search by keyword
kitploit search "web scanner"

# Search by category
kitploit search --category network

# Search by author
kitploit search --author "John Doe"

# Add a tool to your favorites
kitploit add --favorite nmap

# Remove a tool from favorites
kitploit remove --favorite nmap

# List all your favorites
kitploit list --favorites

# Update the local database
kitploit update

# Force a full re-sync
kitploit update --force

# Example configuration
database:
  path: ~/.kitploit/tools.db
  auto_update: true

search:
  default_limit: 20
  case_sensitive: false

cache:
  enabled: true
  ttl: 3600

git clone https://github.com/kitploit/kitploit.git
cd kitploit
pip install -e ".[dev]"
pytest

{"ice_servers": [{"urls": "stun:stun.example.net:3478"}]}
```
I'm ready to translate the Kitploit tool content from English to French. Please provide chunk 19 of 35.```json
{"iceServers": [{"urls": ["turn:turn.example.net:3478"], "username": "u", "credential": "p"}]}
```
`urls` accepte une chaîne ou une liste ; `username` et `credential` concernent TURN et peuvent être
omis pour une entrée STUN uniquement. Le chemin peut être absolu, relatif ou commencer par `~`. Un fichier
qui ne se parse pas arrête le listener au démarrage plutôt que de revenir silencieusement en arrière.

Si une session se retrouve relayée sans que cela ait été demandé, `bitbang connect` le signale
plutôt que de vous laisser vous demander pourquoi elle semble lente. Le listener le journalise
dans tous les cas (`via RELAY`), et `-relay` / `-norelay` forcent la question dans un sens
ou dans l'autre lorsque vous diagnostiquez un chemin.

Il vaut la peine de le préciser : il s'agit de savoir qui transporte les octets, pas qui peut les lire. Un relais ne
voit jamais que du ciphertext DTLS, y compris le nôtre. Lancez le vôtre lorsque vous avez besoin de plus de TURN que nous ne pouvons en fournir (nous limitons actuellement la durée).

### Connexion depuis un navigateur

Ouvrez l'URL. Selon ce qui est servi, vous obtenez :

- **Shell** -- un terminal complet dans la page (couleurs, redimensionnement, copier/coller).
- **Fichiers** -- parcourir, prévisualiser, télécharger et uploader.
- **Proxy** -- saisissez une adresse LAN (`nas.local`, `192.168.1.10:8080`, `localhost:3000/admin`) et utilisez l'application comme si vous étiez en local. Connexions, cookies, uploads et streaming fonctionnent tous.

<!-- TODO: per-feature demos -->
<!-- Remote shell in a browser tab -->
<!-- Streaming Jellyfin through the proxy -->

### Connexion depuis la CLI```
bitbang connect <url>                                   # interactive shell
bitbang connect <url> -- tail -f /var/log/syslog        # one-shot command
bitbang connect <url> -L 15432:db.internal:5432         # local TCP forwarding
bitbang connect <url> -L 14450:nas.local:445 -L 15900:[fd00::20]:5900
bitbang cp <url>:/var/log/app.log ./app.log             # copy files, scp-style
bitbang cp - <url>:/tmp/firmware.bin < firmware.bin     # stdin/stdout work too
```
`-L` ne transmet que **TCP**, comme `ssh -L`. `-L` se lie à `127.0.0.1` sauf si vous passez
`-g`, ce qui rend le port transféré accessible depuis votre réseau local — et
quiconque y accède obtient ce que le tunnel atteint, sans aucune
authentification BitBang devant.

L'écouteur nécessite `bitbang serve forward` ou `bitbang serve`. Par défaut, un
lien `forward` atteint **n'importe quel hôte:port que l'écouteur peut joindre**, pas seulement
celui que vous aviez en tête, donc un lien distribué pour une base de données atteint aussi le reste
de ce réseau. Réduisez-le en nommant ce qu'il peut atteindre :```
bitbang serve forward db.internal:5432        # this link reaches one service
```
Chaque connexion ou appairage réussi est enregistré dans `~/.bitbang/devices.json`, donc par la suite un nom court suffit : `bitbang connect nas1`.

## Prise en charge des plateformes

Un binaire par plateforme, aucune dépendance d'exécution. Tout fonctionne
partout, sauf les deux lignes signalées ci-dessous.

|                                          | Linux | macOS | Windows |
| ---------------------------------------- | :---: | :---: | :-----: |
| Shell, fichiers, proxy (`bitbang serve`)     |  oui  |  oui  |   oui   |
| Redirection TCP (`-L`)                     |  oui  |  oui  |   oui   |
| Liens d'accès -- octroi, expiration, révocation |  oui  |  oui  |   oui   |
| Apportez votre propre TURN                       |  oui  |  oui  |   oui   |
| Appairage avec un code à 6 chiffres               |  oui  |  oui  |   oui   |
| La console de l'écouteur (Entrée)              |  oui  |  oui  |   oui   |
| `bitbang connect`, `bitbang cp`           |  oui  |  oui  |   oui   |
| Visualisation d'une session partagée                  |  oui  |  oui  |   oui   |
| **Hébergement d'un partage** (`bitbang share`)     |  oui  |  oui  |  non *   |
| **Redimensionnement du terminal pendant la connexion**       |  oui  |  oui  |  non **  |

\* `bitbang share` publie une session tmux, donc l'héberger nécessite tmux --
Linux, macOS, ou WSL. Windows natif peut toujours ouvrir les URL de partage avec
`bitbang connect`.

\*\* Un connecteur Windows ne remarque pas le redimensionnement de son terminal, donc le
shell distant conserve la taille qu'il avait au départ jusqu'à ce que vous vous reconnectiez. Unix
obtient cela via `SIGWINCH`, dont Windows n'a pas d'équivalent.

## Sécurité

- **Identité auto-certifiante.** Au premier lancement, `bitbang` génère une paire de clés RSA sous `~/.bitbang/<programme>/` ; l'UID de l'appareil est dérivé de la clé publique, donc usurper un appareil revient à trouver une seconde préimage de son UID.
- **Le secret ne touche jamais le serveur.** Le code d'accès se trouve dans le fragment d'URL (`#…`), que les navigateurs n'envoient jamais -- `bitba.ng` sert d'intermédiaire pour la connexion sans jamais voir l'identifiant qui l'autorise.
- **Chiffrement de bout en bout.** Tout le trafic passe par le DTLS de WebRTC. Le serveur de signalisation ne voit que la clé publique, l'UID dérivé et les métadonnées de connexion -- jamais vos données. Un relais TURN, si nécessaire, ne voit que du texte chiffré.
- **Appairage vérifié.** Le nombre lu à voix haute lors de l'appairage par code est une chaîne d'authentification courte (SAS), calculée indépendamment aux deux extrémités à partir des empreintes DTLS négociées et de deux nonces engagés -- un intermédiaire, dont les empreintes diffèrent nécessairement, ne peut pas faire correspondre les deux nombres.
- **L'URL est un identifiant porteur.** Quiconque l'a obtient ce que vous avez choisi de servir -- un shell, si vous avez exécuté `serve shell`. Partagez-la en conséquence.
- **PIN optionnel** (`--pin`) pour les configurations permanentes ou sans tête, et **mode jetable** (`-ephemeral`) pour une identité fraîche à chaque exécution.
- **Ce que le serveur voit encore.** Pas rien. Il sert d'intermédiaire pour l'introduction, donc
  il observe les adresses IP des deux extrémités, quand elles se connectent et combien elles
  échangent. Le chiffrement de bout en bout le tient hors de vos données, pas hors des
  métadonnées qui les entourent -- *confiance minimale* est une description plus juste que
  *sans confiance*.
- **Un navigateur fait confiance à la page qu'il a chargée.** Le client navigateur est du JavaScript
  servi par le serveur de signalisation, donc ouvrir une URL signifie faire confiance à ce serveur
  pour servir un code honnête. `bitbang connect` n'a pas une telle dépendance : c'est un
  binaire que vous avez installé et vérifié par somme de contrôle. Si cette distinction compte pour vous,
  connectez-vous avec la CLI.

La manière dont les deux extrémités s'authentifient mutuellement, afin que le serveur de signalisation ne puisse pas
s'insérer dans la connexion, est détaillée ici : [*Signalisation sans confiance : Authentification sans autorité centrale*](https://github.com/richlegrand/bitbang/blob/main/trustless-signaling.md).

## Pourquoi ?

- **Rien à ouvrir ou à configurer.** Fonctionne derrière un NAT, un CGNAT ou un réseau verrouillé -- aucune modification de routeur, aucun VPN, aucun démon de tunnel.
- **Rien à installer côté connexion.** Un navigateur suffit. Une CLI est là quand vous voulez des scripts, des pipes et la copie de fichiers.
- **Privé par conception.** Le trafic est WebRTC/DTLS, pair à pair. Le serveur de signalisation ne le voit jamais ; si un chemin direct n'est pas possible, un relais TURN transporte uniquement du texte chiffré.
- **Aucun compte, aucune télémétrie.**


### Pourquoi ne pas simplement utiliser SSH ? Ou Tailscale ?

Réponse courte : pour une machine sur laquelle vous pouvez déjà vous connecter en SSH, ou une flotte de vos propres
appareils sur lesquels vous pouvez installer, continuez à utiliser ce que vous avez. `bitbang` est pour quand
l'extrémité distante est une personne plutôt qu'un appareil, ou quand vous ne pouvez rien installer
là où vous êtes assis. Les deux questions sont traitées en détail dans la
**[FAQ](https://github.com/richlegrand/bitbang-cli/blob/HEAD/FAQ.md)**.

## Installation```
curl -sSfL bitba.ng/install | sh
```
Linux et macOS. Détecte votre OS et votre architecture (`amd64`, `arm64` et `armv7` sur Linux), télécharge le binaire depuis la dernière [version GitHub](https://github.com/richlegrand/bitbang-cli/releases), vérifie son SHA-256 par rapport au `checksums.txt` de la version, et l'installe dans `~/.local/bin/bitbang`.

Les builds Windows sont publiés sous les noms `bitbang-windows-amd64.exe` et
`bitbang-windows-arm64.exe`. Téléchargez le binaire approprié depuis Releases,
renommez-le en `bitbang.exe`, et placez-le sur votre `PATH`.
**Compiler depuis les sources :** voir [ci-dessous](#building-from-source).

**macOS et Gatekeeper.** La commande d'installation en une ligne ci-dessus n'est pas affectée : `curl` ne
définit pas l'attribut `com.apple.quarantine`, donc le binaire qu'il récupère s'exécute
normalement. Si vous téléchargez plutôt `bitbang-darwin-arm64` depuis la page Releases
dans un navigateur, macOS le met en quarantaine et refuse de l'ouvrir, car les binaires
de version ne sont pas notarisés. Supprimez cette restriction avec l'une des commandes suivantes :```
xattr -d com.apple.quarantine ./bitbang-darwin-arm64
```
ou cliquez avec le bouton droit sur le fichier dans le Finder et choisissez Ouvrir, ce qui offre une dérogation ponctuelle. Vous pouvez également compiler à partir des sources, ce qui ne déclenche jamais la quarantaine.

**Windows et SmartScreen.** La même chose se produit sous Windows, pour la même raison. Un téléchargement via le navigateur attache la Marque du Web, donc la première exécution affiche *« Windows a protégé votre PC »* — choisissez **Plus d'informations**, puis **Exécuter quand même**. Les binaires de la version ne sont pas signés avec un certificat de code, c'est donc attendu plutôt qu'un signe de problème. Récupérer le `.exe` avec `curl` ou `Invoke-WebRequest` de PowerShell ne l'attache pas, pas plus que la compilation à partir des sources.

### Options d'installation

Épinglez une version, modifiez l'emplacement ou lisez le script avant de l'exécuter :```
curl -sSfL bitba.ng/install | sh -s -- --version 0.5.0
curl -sSfL bitba.ng/install | sh -s -- --prefix /usr/local/bin

curl -sSfL bitba.ng/install -o install.sh && less install.sh && sh install.sh
```
Les tags de version n'ont pas de préfixe `v` (`0.5.0`, pas `v0.5.0`).

### Comment fonctionne l'URL d'installation

`bitba.ng/install` est une redirection, pas un script hébergé. La chaîne :

1. `curl` accède à `https://bitba.ng/install`, qui redirige en 302 vers [`install.sh`](https://github.com/richlegrand/bitbang-cli/blob/HEAD/install.sh) dans ce dépôt (sur `main`).
2. Le script s'exécute dans votre shell, détecte le système d'exploitation et l'architecture, puis télécharge la ressource binaire depuis `https://github.com/richlegrand/bitbang-cli/releases/latest/download/bitbang-linux-<arch>`.
3. Il récupère `checksums.txt` depuis la même version et vérifie le SHA-256 du binaire.
4. Il installe dans `~/.local/bin` (remplaçable).

Le script d'installation vit dans ce dépôt, à côté du code qu'il installe — vous pouvez donc le consulter en même temps que le binaire, et l'hôte canonique bitba.ng ne possède que l'URL courte. Les auto-hébergeurs peuvent pointer le `/install` de leur propre hôte vers le script qu'ils fournissent : la variable d'environnement `INSTALL_URL` du serveur de signalisation contrôle la cible de redirection (vide → 404).

## Référence des commandes

Chaque sous-commande et chaque option figure dans **[CLI.md](https://github.com/richlegrand/bitbang-cli/blob/HEAD/CLI.md)**, et `bitbang <commande>
--help` affiche la même chose dans le terminal.

## Compilation depuis les sources

Nécessite Go 1.25+. Go pur, lié statiquement (`CGO_ENABLED=0`) — compilation croisée triviale, aucune dépendance d'exécution.```
go build ./cmd/bitbang/

# cross-compile:
GOOS=linux   GOARCH=arm64        go build -o bitbang-arm64 ./cmd/bitbang/
GOOS=linux   GOARCH=arm GOARM=7  go build -o bitbang-armv7 ./cmd/bitbang/
GOOS=windows GOARCH=amd64        go build -o bitbang.exe   ./cmd/bitbang/
GOOS=darwin  GOARCH=arm64        go build -o bitbang-macos ./cmd/bitbang/
```
Depuis l'invite de commandes Windows :```bat
go build -o bitbang.exe .\cmd\bitbang
go test .\...
run_tests.cmd unit
```
Les commandes shell, le partage de fichiers, le proxy et le client CLI sont pris en charge sur
Windows. Les shells interactifs du navigateur et de la CLI utilisent Windows ConPTY, y compris
l'écho de saisie du terminal, l'édition de ligne, la sortie VT et les événements de redimensionnement. ConPTY nécessite
Windows 10 version 1809 ou Windows Server 2019 ou version ultérieure.

## Diagrammes

<p align="center">
  <img src="https://assets.kitploit.com/production/public/readmes/47068/d68fcddad62ab84f11a549906a2b5abf2330fb25f39b3c1a1266eac7257a080d.png" alt="Shell CLI bitbang et partage de fichiers" width="760">
  <img src="https://assets.kitploit.com/production/public/readmes/47068/55bb6866c22504a6434e3dee8cb998e747cd73cb9d0bfa5e0bc0ede7b90ce262.png" alt="Fonctionnement du proxy CLI bitbang" width="720">  
</p>

## Feuille de route

Disponible aujourd'hui : **shell, fichiers et proxy**, accessibles depuis le navigateur ou la CLI, plus la **redirection de port TCP**, la copie de fichiers de type scp, **l'appairage ad hoc** avec une table d'appareils enregistrée, le **partage de terminal** (`bitbang share`) et les **liens d'accès** (`bitbang link`) qui restreignent et font expirer ce qu'une URL accorde. Conçu et en cours de route :

- **Pont série** -- piloter un `/dev/ttyUSB0` distant depuis un port virtuel local (par ex. exécuter l'IDE Arduino sur Internet). Un problème a été ouvert [ici](https://github.com/richlegrand/bitbang-cli/issues/3).
- **Bureau à distance** -- écran via une piste vidéo WebRTC, clavier/souris via le canal de données.

## Licence

MIT -- voir [LICENSE](https://github.com/richlegrand/bitbang-cli/blob/HEAD/LICENSE).

## Contribution

Les issues et les PR sont les bienvenues.

Les recettes sont différentes : elles vivent dans le [cookbook](https://github.com/richlegrand/bitbang/blob/main/cookbook.md),
dans le dépôt [bitbang](https://github.com/richlegrand/bitbang), car elles couvrent
chaque projet plutôt que celui-ci. Ajouter une recette est une PR là-bas.

La faire *référencer* est une seconde petite PR par projet dont le README doit la mettre en avant
-- la liste [Recettes](#recettes) ci-dessus est maintenue ici à la main. C'est
délibéré : chaque projet décide quelles recettes valent la peine d'être présentées à ses
propres lecteurs, plutôt que chaque README ne grossisse avec chaque recette.