lfs-insim 0.1.0__tar.gz

lfs_insim-0.1.0/.gitignore

@@ -0,0 +1,22 @@
+# Python
+__pycache__/
+*.py[cod]
+.venv/
+build/
+dist/
+*.egg-info/
+.pytest_cache/
+.ruff_cache/
+.mypy_cache/
+
+# Especificación oficial descargada de lfs.net (W1.4): no se versiona
+spec/cache/
+
+# Informes de la prueba en vivo (W3.1): llevan nombres de jugadores
+tests/live_reports/
+
+# Editores y sistema
+.vscode/
+.idea/
+Thumbs.db
+.DS_Store

lfs_insim-0.1.0/CHANGELOG.md

@@ -0,0 +1,14 @@
+# Changelog
+
+## 0.1.0
+
+First release (alpha). The API may still change before 1.0.
+
+- InSim over TCP: every packet of the protocol, generated from the specification published at
+  lfs.net; handlers with `@insim.on`, chat commands, `say()`/`command()`, `request()`/
+  `request_all()`, `every()`, and automatic reconnection.
+- OutSim (`OutSimPack` and `OutSimPack2`) and OutGauge over UDP, alone or together with InSim
+  through `run()`.
+- `lfs_insim.state.Roster` (connections and players) and `lfs_insim.text` (`plain`,
+  `strip_colours`).
+- Checked against a real LFS 0.8C, and by the tests against a fake LFS.

lfs_insim-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Adrian Pascarella
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

lfs_insim-0.1.0/PKG-INFO

@@ -0,0 +1,94 @@
+Metadata-Version: 2.5
+Name: lfs-insim
+Version: 0.1.0
+Summary: A Python library for the Live for Speed InSim protocol (InSim, OutSim, OutGauge).
+Project-URL: Homepage, https://github.com/AdrianPascarella/AP_LFS_InSim
+Project-URL: Issues, https://github.com/AdrianPascarella/AP_LFS_InSim/issues
+Author: Adrian Pascarella
+License-Expression: MIT
+License-File: LICENSE
+Keywords: insim,lfs,live for speed,outgauge,outsim,racing,simulator
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Games/Entertainment :: Simulation
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+
+# lfs_insim
+
+A Python library for the [Live for Speed](https://www.lfs.net) InSim protocol: **InSim** (TCP),
+**OutSim** and **OutGauge** (UDP). Plain `import`, no framework, no dependencies.
+
+> **Status: alpha.** The library is checked against a real LFS (0.8C), but its API may still
+> change before 1.0.
+
+- Python 3.11 or newer, no dependencies, fully typed.
+- Every packet class is generated from the official specification published at lfs.net, so the
+  fields are named exactly as in `InSim.txt`.
+- Handlers with decorators, `await insim.request(...)`, chat commands, a roster of connections
+  and players, and automatic reconnection if LFS restarts.
+
+## Install
+
+```
+pip install lfs-insim
+```
+
+## A first program
+
+In LFS, type `/insim=29999` to let it listen for InSim. Then run this and type `!hello` in the
+game:
+
+```python
+from lfs_insim import Command, InSim
+from lfs_insim.packets import IS_VER
+
+insim = InSim(name="hello", prefix="!")  # admin_password="..." if LFS has one
+
+
+@insim.on(IS_VER)
+def connected(packet: IS_VER) -> None:
+    print(f"Connected to LFS {packet.Version}, InSim {packet.InSimVer}")
+
+
+@insim.on_command("hello")
+def hello(command: Command) -> None:
+    command.reply("Hello from Python")
+
+
+if __name__ == "__main__":
+    insim.run()  # blocks until Ctrl+C; reconnects on its own if LFS restarts
+```
+
+## What is in the box
+
+| You want to… | Use |
+| --- | --- |
+| Receive a packet | `@insim.on(IS_XXX)` |
+| Answer a chat command | `@insim.on_command("name")` |
+| Send packets, chat or `/commands` | `insim.send(...)`, `insim.say(...)`, `insim.command(...)` |
+| Ask LFS and wait for the answer | `await insim.request(IS_STA)`, `request_all(...)` |
+| Run something on a rhythm | `@insim.every(seconds)` |
+| Know who is connected and who is driving | `lfs_insim.state.Roster` |
+| Read car physics or the dashboard | `OutSim` and `OutGauge` |
+| Show LFS text without colour codes | `lfs_insim.text.plain(...)` |
+
+The guide is in [`docs/`](docs/README.md). Short, runnable programs are in [`examples/`](examples): `hello.py`, `who.py`, `buttons.py` and
+`gauge.py`.
+
+## Development
+
+This repository is worked on with the notes in [`docs/dev`](docs/dev) (in Spanish). To check
+everything: `python scripts/verify.py`.
+
+## License
+
+MIT — see [LICENSE](LICENSE).

lfs_insim-0.1.0/README.md

@@ -0,0 +1,70 @@
+# lfs_insim
+
+A Python library for the [Live for Speed](https://www.lfs.net) InSim protocol: **InSim** (TCP),
+**OutSim** and **OutGauge** (UDP). Plain `import`, no framework, no dependencies.
+
+> **Status: alpha.** The library is checked against a real LFS (0.8C), but its API may still
+> change before 1.0.
+
+- Python 3.11 or newer, no dependencies, fully typed.
+- Every packet class is generated from the official specification published at lfs.net, so the
+  fields are named exactly as in `InSim.txt`.
+- Handlers with decorators, `await insim.request(...)`, chat commands, a roster of connections
+  and players, and automatic reconnection if LFS restarts.
+
+## Install
+
+```
+pip install lfs-insim
+```
+
+## A first program
+
+In LFS, type `/insim=29999` to let it listen for InSim. Then run this and type `!hello` in the
+game:
+
+```python
+from lfs_insim import Command, InSim
+from lfs_insim.packets import IS_VER
+
+insim = InSim(name="hello", prefix="!")  # admin_password="..." if LFS has one
+
+
+@insim.on(IS_VER)
+def connected(packet: IS_VER) -> None:
+    print(f"Connected to LFS {packet.Version}, InSim {packet.InSimVer}")
+
+
+@insim.on_command("hello")
+def hello(command: Command) -> None:
+    command.reply("Hello from Python")
+
+
+if __name__ == "__main__":
+    insim.run()  # blocks until Ctrl+C; reconnects on its own if LFS restarts
+```
+
+## What is in the box
+
+| You want to… | Use |
+| --- | --- |
+| Receive a packet | `@insim.on(IS_XXX)` |
+| Answer a chat command | `@insim.on_command("name")` |
+| Send packets, chat or `/commands` | `insim.send(...)`, `insim.say(...)`, `insim.command(...)` |
+| Ask LFS and wait for the answer | `await insim.request(IS_STA)`, `request_all(...)` |
+| Run something on a rhythm | `@insim.every(seconds)` |
+| Know who is connected and who is driving | `lfs_insim.state.Roster` |
+| Read car physics or the dashboard | `OutSim` and `OutGauge` |
+| Show LFS text without colour codes | `lfs_insim.text.plain(...)` |
+
+The guide is in [`docs/`](docs/README.md). Short, runnable programs are in [`examples/`](examples): `hello.py`, `who.py`, `buttons.py` and
+`gauge.py`.
+
+## Development
+
+This repository is worked on with the notes in [`docs/dev`](docs/dev) (in Spanish). To check
+everything: `python scripts/verify.py`.
+
+## License
+
+MIT — see [LICENSE](LICENSE).

lfs_insim-0.1.0/docs/README.md

@@ -0,0 +1,10 @@
+# lfs_insim documentation
+
+1. [Getting started](getting-started.md): install, let LFS listen, write and run a first program.
+2. [InSim](insim.md): handlers, chat commands, sending, asking LFS, running on a rhythm, buttons.
+3. [Who is who, and text](roster-and-text.md): `Roster`, and how LFS text (colours, escapes) arrives.
+4. [OutSim and OutGauge](outsim-outgauge.md): the UDP data, alone or together with InSim.
+
+Runnable programs are in [`examples/`](../examples). Every packet class and field is named as in
+the official [InSim.txt](https://www.lfs.net/programmer/insim) specification (`IS_NPL.PName`,
+`IS_STA.NumP`...); the editor shows them, and their docstrings come from the specification.

lfs_insim-0.1.0/docs/getting-started.md

@@ -0,0 +1,82 @@
+# Getting started
+
+## Install
+
+```
+pip install lfs-insim
+```
+
+Python 3.11 or newer. There are no dependencies.
+
+## Let LFS listen
+
+LFS only accepts InSim connections when you ask it to. In the game, type:
+
+```
+/insim=29999
+```
+
+Port 29999 is the default of `InSim`. If LFS has an admin password, pass it as
+`InSim(admin_password="...")`.
+
+## A first program
+
+```python
+from lfs_insim import Command, InSim
+from lfs_insim.packets import IS_VER
+
+insim = InSim(name="hello", prefix="!")
+
+
+@insim.on(IS_VER)
+def connected(packet: IS_VER) -> None:
+    print(f"Connected to LFS {packet.Version}, InSim {packet.InSimVer}")
+
+
+@insim.on_command("hello")
+def hello(command: Command) -> None:
+    command.reply("Hello from Python")
+
+
+if __name__ == "__main__":
+    insim.run()
+```
+
+- `InSim(name=..., prefix="!")` prepares the connection; nothing is sent yet. `name` is how your
+  program is shown in LFS (up to 15 characters). `prefix` is one character: what users type
+  before a command.
+- `@insim.on(IS_VER)` calls the function for every `IS_VER` packet LFS sends. The same works for
+  any packet: `IS_NPL` (a player joins), `IS_LAP`, `IS_BTC` (a button click)...
+- `@insim.on_command("hello")` calls the function when someone types `!hello`.
+- `insim.run()` connects and dispatches packets until Ctrl+C. If LFS is not running yet, or
+  closes, it keeps trying again.
+
+Run it, then type `!hello` in LFS.
+
+## `def` or `async def`
+
+Handlers may be plain functions (they run at once, so keep them quick) or `async def` (they run
+as tasks and may `await`). An exception in a handler is logged and never stops the others.
+
+If your program already runs an asyncio event loop, use the connection as a context manager
+instead of `run()`:
+
+```python
+import asyncio
+
+from lfs_insim import InSim
+
+insim = InSim(name="inside-a-loop")
+
+
+async def main() -> None:
+    async with insim:  # connects in the background and keeps the connection up
+        await asyncio.sleep(60)
+
+
+asyncio.run(main())
+```
+
+## Next
+
+[InSim](insim.md) covers everything a connection can do.

lfs_insim-0.1.0/docs/insim.md

@@ -0,0 +1,102 @@
+# InSim
+
+```python
+from lfs_insim import InSim
+
+insim = InSim(name="my program", prefix="!")
+```
+
+The options of `InSim(...)`: `admin_password`, `host` and `port` (default `127.0.0.1:29999`),
+`flags` (the `ISF` options, such as `ISF.MCI | ISF.LOCAL`), `interval_ms` (time between
+`IS_MCI`/`IS_NLP` packets) and `prefix`.
+
+## Receiving
+
+```python
+from lfs_insim.packets import IS_NPL
+
+
+@insim.on(IS_NPL)
+def joined(packet: IS_NPL) -> None:
+    print(packet.PName, "is on track in a", packet.CName)
+```
+
+Text fields are `str`. They keep LFS's `^` codes; see [text](roster-and-text.md#text).
+
+### Chat commands
+
+With a `prefix`, `@insim.on_command("kick")` is called for `!kick Bob` with a `Command`:
+
+```python
+from lfs_insim import Command
+
+
+@insim.on_command("kick")
+def kick(command: Command) -> None:
+    # command.name == "kick", command.args == ("Bob",)
+    # command.ucid: the connection that typed it; command.plid: its player (0 if none)
+    command.reply(f"Kicking {', '.join(command.args)}")  # only the sender sees this
+```
+
+Names are matched in any case. Commands are hidden from the other users. A command with no
+function is left alone, since it may be meant for another program.
+
+### On connection, and on a rhythm
+
+```python
+@insim.on_connect
+async def start() -> None:
+    ...  # after every connection and reconnection: ask LFS for the initial state here
+
+
+@insim.every(2)
+async def tick() -> None:
+    ...  # every 2 seconds while connected; calls never overlap
+```
+
+## Sending
+
+```python
+from lfs_insim.packets import IS_MST
+
+insim.say("Hello everyone")        # the chat; everyone sees it
+insim.say("Just you", to=3)        # only the connection with UCID 3 (0 = this computer)
+insim.command("/restart")          # an LFS command
+insim.send(IS_MST(Msg="/end"))     # any packet; several at once: insim.send(a, b)
+```
+
+`say()` picks the right packet for you and raises `ValueError` if the text is too long
+(`PacketError` is a `ValueError`). `send()` raises `ConnectionError` if LFS is not connected.
+
+## Asking LFS
+
+```python
+from lfs_insim.packets import IS_NCN, IS_STA
+
+
+@insim.every(5)
+async def report() -> None:
+    state = await insim.request(IS_STA)            # one packet
+    everyone = await insim.request_all(IS_NCN)     # a list: one per connection
+    print(state.NumP, len(everyone))
+```
+
+`request` raises `TimeoutError` if LFS does not answer within 2 seconds (change it with
+`timeout=`). The answers also reach your `@insim.on` handlers. Asking for a packet that LFS does
+not send on request raises `TypeError` and says which function to use instead.
+
+## Buttons
+
+Buttons are `IS_BTN` packets; clicks come back as `IS_BTC` (and `IS_BTT` for text typed into a
+button). Each button of your program needs its own `ClickID` (0 to 239), and sending a button
+again with the same `ClickID` updates it. See [`examples/buttons.py`](../examples/buttons.py).
+
+## Closing
+
+`insim.run()` ends with Ctrl+C. From a handler or an event loop, `await insim.close()` sends the
+goodbye to LFS and stops reconnecting.
+
+## Without `run()`
+
+`await insim.connect()` connects once (no reconnection) and returns; `wait_closed()` waits until
+it ends. Use `async with insim:` or `run()` unless you need that.

lfs_insim-0.1.0/docs/outsim-outgauge.md

@@ -0,0 +1,71 @@
+# OutSim and OutGauge
+
+Both are UDP: LFS sends them to a port of your choice, and you listen. Neither needs InSim.
+
+## OutGauge (the dashboard)
+
+With LFS closed, set these lines in its `cfg.txt`:
+
+```
+OutGauge Mode 1
+OutGauge IP 127.0.0.1
+OutGauge Port 30001
+```
+
+If you also set `OutGauge ID`, LFS adds that number to every packet (`packet.ID`).
+
+```python
+from lfs_insim import OutGauge
+from lfs_insim.packets import OutGaugePack
+
+gauge = OutGauge(port=30001)
+
+
+@gauge.on(OutGaugePack)
+def dashboard(packet: OutGaugePack) -> None:
+    print(f"{packet.Speed * 3.6:.0f} km/h at {packet.RPM:.0f} rpm")
+
+
+if __name__ == "__main__":
+    gauge.run()
+```
+
+LFS can send up to 100 packets a second. If you only need them now and then, keep the last one
+and act on a rhythm (see [`examples/gauge.py`](../examples/gauge.py)).
+
+## OutSim (the car's motion)
+
+The `OutSim ...` lines of `cfg.txt` work the same way. With `OutSim Opts 0`, LFS sends
+`OutSimPack`; with any other options, `OutSimPack2`, which carries only the parts those options
+select. Give the same options to `OutSim`:
+
+```python
+from lfs_insim import OutSim
+from lfs_insim.packets import OSO, OutSimPack2
+
+outsim = OutSim(port=30002, options=OSO.MAIN | OSO.INPUTS)
+
+
+@outsim.on(OutSimPack2)
+def motion(packet: OutSimPack2) -> None:
+    print(packet)  # the parts that were not sent are None
+```
+
+The options must match `OutSim Opts` in `cfg.txt`, written in hexadecimal there. If a datagram
+cannot be read, the library logs one warning pointing at `cfg.txt` and skips it.
+
+## Together with InSim
+
+`run()` starts several sources in one process and one event loop:
+
+```python
+from lfs_insim import InSim, OutGauge, run
+
+insim = InSim(name="both")
+gauge = OutGauge(port=30001)
+
+run(insim, gauge)
+```
+
+If the port is already taken, starting raises `OSError`. Port 30000 is often in use by other
+programs; pick another.

lfs_insim-0.1.0/docs/roster-and-text.md

@@ -0,0 +1,51 @@
+# Who is who, and text
+
+## Roster
+
+Almost every program needs to know who is connected and who is driving. `Roster` follows the
+packets for you:
+
+```python
+from lfs_insim import InSim
+from lfs_insim.packets import IS_NPL
+from lfs_insim.state import Roster
+
+insim = InSim(name="who")
+roster = Roster(insim)  # create it before running the connection
+
+
+@insim.on(IS_NPL)
+def joined(packet: IS_NPL) -> None:
+    player = roster.players[packet.PLID]
+    print(player.name, "is driven from", player.connection.username or "this computer")
+```
+
+- `roster.connections` maps UCID to a `Connection` (`username`, `name`, `admin`, `remote`,
+  `players`).
+- `roster.players` maps PLID to a `Player` (`name`, `plate`, `car`, `is_ai`, `in_pits`,
+  `connection`). An AI belongs to the connection that added it.
+- On every connection and reconnection it asks LFS for everyone, so it starts complete.
+- It is already up to date in your handlers: when someone arrives it is updated before them, and
+  when someone leaves (`IS_PLL`, `IS_CNL`) after them, so you can still look up who is leaving.
+- It is read only: change things in LFS, not in the roster.
+
+See [`examples/who.py`](../examples/who.py).
+
+## Text
+
+Text fields (`PName`, `Msg`, ...) arrive as `str`, with LFS's `^` codes kept as LFS sends them:
+colours (`^1`, `^7`...) and escaped characters (`^v` is `|`, `^h` is `#`, `^^` is `^`). The
+library has already turned LFS's code-page bytes into the right characters, so accents and other
+alphabets just work.
+
+```python
+from lfs_insim.text import plain, strip_colours
+
+plain("^4^h773 ^7Bob")         # '#773 Bob'  to print or save
+strip_colours("^1Red ^7car")   # 'Red car'   only the colours
+```
+
+Use `plain()` to show text outside LFS. Do not send its result back to LFS: the escapes are
+gone, so send the original.
+
+`IS_MSO.text` is the message without the player's name in front of it.

lfs_insim-0.1.0/examples/buttons.py

@@ -0,0 +1,71 @@
+"""Buttons in LFS: one to click, one to type into. Type !buttons in LFS to show them, !hide to
+remove them.
+
+LFS must be listening for InSim: type /insim=29999 in LFS first.
+"""
+
+from lfs_insim import Command, InSim
+from lfs_insim.packets import BFN, IS_BFN, IS_BTC, IS_BTN, IS_BTT, ISB
+
+insim = InSim(name="buttons", prefix="!")
+
+CLICK_ME, TYPE_HERE = 1, 2  # ClickID: each button of this program needs its own (0 to 239)
+clicks = 0
+
+
+def show(ucid: int) -> None:
+    """Send both buttons to a connection. Sending one again with its ClickID updates it."""
+    insim.send(
+        IS_BTN(
+            ReqI=1,  # LFS needs it non-zero
+            UCID=ucid,  # 0 = this computer, 255 = everyone
+            ClickID=CLICK_ME,
+            BStyle=ISB.CLICK | ISB.LIGHT,
+            L=70,  # position and size: the screen is 200 x 200
+            T=40,
+            W=60,
+            H=8,
+            Text=f"Clicked {clicks} times",
+        ),
+        IS_BTN(
+            ReqI=1,
+            UCID=ucid,
+            ClickID=TYPE_HERE,
+            BStyle=ISB.CLICK | ISB.DARK,
+            TypeIn=20,  # clicking opens a text box for up to 20 characters
+            L=70,
+            T=50,
+            W=60,
+            H=8,
+            Text="Type something",
+            Caption="Your text",
+        ),
+    )
+
+
+@insim.on_command("buttons")
+def buttons(command: Command) -> None:
+    show(command.ucid)
+
+
+@insim.on_command("hide")
+def hide(command: Command) -> None:
+    insim.send(IS_BFN(SubT=BFN.CLEAR, UCID=command.ucid))
+
+
+@insim.on(IS_BTC)
+def clicked(packet: IS_BTC) -> None:
+    global clicks
+    if packet.ClickID == CLICK_ME:
+        clicks += 1
+        show(packet.UCID)
+
+
+@insim.on(IS_BTT)
+def typed(packet: IS_BTT) -> None:
+    if packet.ClickID == TYPE_HERE:
+        insim.say(f"You typed: {packet.Text}", to=packet.UCID)
+
+
+if __name__ == "__main__":
+    insim.run()

lfs_insim-0.1.0/examples/gauge.py

@@ -0,0 +1,33 @@
+"""A fixed rhythm, async and OutGauge at once: every 2 s, show the speed of your car in LFS.
+
+LFS must be listening for InSim (type /insim=29999 in LFS) and sending OutGauge: with LFS
+closed, set these lines in its cfg.txt: "OutGauge Mode 1" and "OutGauge Port 30001".
+"""
+
+from lfs_insim import InSim, OutGauge, run
+from lfs_insim.packets import IS_MSL, IS_STA, OutGaugePack
+
+insim = InSim(name="gauge")
+gauge = OutGauge(port=30001)  # UDP; port 30000 is often taken by other programs
+
+latest: OutGaugePack | None = None
+
+
+@gauge.on(OutGaugePack)
+def dashboard(packet: OutGaugePack) -> None:
+    global latest
+    latest = packet  # up to 100 a second: keep the last one, and act on a rhythm
+
+
+@insim.every(2)
+async def show() -> None:
+    state = await insim.request(IS_STA)  # waits for LFS without stopping anything else
+    if latest is None:
+        text = "No OutGauge data yet: is a car on track?"
+    else:
+        text = f"{latest.Speed * 3.6:.0f} km/h at {latest.RPM:.0f} rpm"
+    insim.send(IS_MSL(Msg=f"{text} ({state.NumP} in the race)"))  # only on this computer
+
+
+if __name__ == "__main__":
+    run(insim, gauge)  # one program, both sources

lfs_insim-0.1.0/examples/hello.py

@@ -0,0 +1,23 @@
+"""Answer a chat command: type !hello in LFS and it answers you.
+
+LFS must be listening for InSim: type /insim=29999 in LFS first.
+"""
+
+from lfs_insim import Command, InSim
+from lfs_insim.packets import IS_VER
+
+insim = InSim(name="hello", prefix="!")  # admin_password="..." if LFS has one
+
+
+@insim.on(IS_VER)
+def connected(packet: IS_VER) -> None:
+    print(f"Connected to LFS {packet.Version}, InSim {packet.InSimVer}")
+
+
+@insim.on_command("hello")
+def hello(command: Command) -> None:
+    command.reply("Hello from Python")
+
+
+if __name__ == "__main__":
+    insim.run()  # blocks until Ctrl+C; reconnects on its own if LFS restarts