bricklogger 0.2.2__tar.gz → 0.2.3__tar.gz

{bricklogger-0.2.2 → bricklogger-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bricklogger
-Version: 0.2.2
+Version: 0.2.3
 Summary: Data bridge for building automation: collects data based on a Brick model and writes it to time-series databases
 Keywords: brick,bacnet,building-automation,timescaledb,data-logger
 Author: Michael Rosenlund
@@ -74,16 +74,18 @@ page is the short version.
 
 ## Install
 
+As the login that is to run the logger, not as root:
+
 ```bash
-curl -fsSL https://github.com/CX1-ApS/bricklogger/releases/latest/download/install.sh | sudo sh
+curl -LsSf https://astral.sh/uv/install.sh | sh    # uv, if the machine has none
+uv tool install bricklogger
 ```
 
-The script brings its own Python, so the machine needs only `curl`. With
-`sudo` it installs a service: the program under `/opt/bricklogger`, the
-configuration in `/etc/bricklogger`, the data in `/var/lib/bricklogger` and
-three systemd units, left stopped. Without `sudo` everything stays in your home
-directory. `--version 0.2.2` installs a given version; options come after
-`--` when the script is piped: `… | sudo sh -s -- --version 0.2.2`.
+uv brings a Python that fits, so the machine needs nothing else. Everything
+stays in that login's home directory: the program in uv's tool directory, the
+command in `~/.local/bin`, the configuration in `~/.config/bricklogger` and the
+data in `~/.local/share/bricklogger`. `uv tool install bricklogger==0.2.3`
+installs a given version.
 
 **As a container** the same program is `ghcr.io/cx1-aps/bricklogger`, with a
 compose file for the daemon, the web interface and the MCP server; see
@@ -104,9 +106,9 @@ Bricklogger creates and migrates its own tables at the first start.
 ## First setup
 
 ```bash
-bricklogger init                        # guided: sources, destinations, secrets
+bricklogger init                        # guided: sources, destinations, secrets, services
 bricklogger validate                    # after any edit by hand
-bricklogger daemon start                # or: sudo systemctl enable --now bricklogger
+bricklogger services install --web      # if init did not: the daemon and the web interface
 bricklogger model upload building.ttl   # validate, infer, activate
 bricklogger status
 bricklogger points --outcome active     # the last value of every point
@@ -115,17 +117,17 @@ bricklogger points --outcome active     # the last value of every point
 `init` asks for the settings of each source and destination and writes four
 files: `sources.yaml`, `destinations.yaml`, `rules.yaml` and `daemon.yaml`.
 Secrets, such as the database password, go into an `env` file beside them and
-are referred to as `${NAME}`. The first rule set accepts every point in the
+are referred to as `${NAME}`. Last, `init` offers to run the daemon — and the
+web interface and the MCP server, if you want them — as `systemd --user`
+services that start at boot. The first rule set accepts every point in the
 model every five minutes; [rules](https://cx1-aps.github.io/bricklogger/features/configuration/)
 narrow that down by class, location, equipment or any SPARQL pattern.
 
 ## The web interface and an assistant
 
-```bash
-bricklogger serve        # http://127.0.0.1:8421
-```
-
-Everything the CLI does can be done there, and the model explorer shows the
+The web interface is at `http://127.0.0.1:8421` once its service runs, or
+after `bricklogger serve` in a terminal. Everything the CLI does can be done
+there, and the model explorer shows the
 building as a tree and a graph, with every point's outcome and value.
 
 To let an AI assistant that speaks MCP set up sources, destinations and rules,
@@ -145,7 +147,7 @@ before it writes, and never takes a secret's value. See
 bricklogger plugins                          # what is installed
 bricklogger plugins add bricklogger-ibos     # add a plugin from PyPI
 bricklogger plugins remove ibos              # remove one by its type
-sudo systemctl restart bricklogger           # the daemon reads plugins at start
+systemctl --user restart bricklogger         # the daemon reads plugins at start
 ```
 
 A plugin is a Python package that provides a source or a destination type. A
@@ -169,14 +171,26 @@ See [notifications](https://cx1-aps.github.io/bricklogger/features/notifications
 
 ```bash
 bricklogger update status        # what there is to upgrade
-sudo bricklogger update all      # Bricklogger and the plugins together
+bricklogger update all           # Bricklogger and the plugins together
 ```
 
 `update` checks the configuration with the new version before it restarts
 anything, and puts the previous versions back if it does not hold; the
 configuration and the data stay where they are. `update core` upgrades
-Bricklogger alone, `update <type>` one plugin. Running the install script
-again works too. A container pulls the new image instead.
+Bricklogger alone, `update <type>` one plugin. Do not run
+`uv tool install bricklogger` again over an installation with plugins: it
+uninstalls every plugin not named with `--with`. A container pulls the new
+image instead.
+
+**Upgrading from 0.2 installed with the install script:** the install script
+is gone, and so is installing as root. Remove the old installation with the
+script it came from — `curl -fsSL
+https://github.com/CX1-ApS/bricklogger/releases/download/v0.2.2/install.sh |
+sudo sh -s -- --uninstall`, without `sudo` for one in a home directory — then
+install as above, add the plugins again with `bricklogger plugins add`, copy
+the configuration, its `env` file and the data over if they lay in
+`/etc/bricklogger` and `/var/lib/bricklogger` — with `data_dir` in
+`daemon.yaml` changed to the new place — and run `bricklogger services install`.
 
 **Upgrading from 0.1 with an iBOS source:** iBOS is no longer built in. The
 `ibos` instance shows as failed until the plugin is added with

{bricklogger-0.2.2 → bricklogger-0.2.3}/README.md

@@ -29,16 +29,18 @@ page is the short version.
 
 ## Install
 
+As the login that is to run the logger, not as root:
+
 ```bash
-curl -fsSL https://github.com/CX1-ApS/bricklogger/releases/latest/download/install.sh | sudo sh
+curl -LsSf https://astral.sh/uv/install.sh | sh    # uv, if the machine has none
+uv tool install bricklogger
 ```
 
-The script brings its own Python, so the machine needs only `curl`. With
-`sudo` it installs a service: the program under `/opt/bricklogger`, the
-configuration in `/etc/bricklogger`, the data in `/var/lib/bricklogger` and
-three systemd units, left stopped. Without `sudo` everything stays in your home
-directory. `--version 0.2.2` installs a given version; options come after
-`--` when the script is piped: `… | sudo sh -s -- --version 0.2.2`.
+uv brings a Python that fits, so the machine needs nothing else. Everything
+stays in that login's home directory: the program in uv's tool directory, the
+command in `~/.local/bin`, the configuration in `~/.config/bricklogger` and the
+data in `~/.local/share/bricklogger`. `uv tool install bricklogger==0.2.3`
+installs a given version.
 
 **As a container** the same program is `ghcr.io/cx1-aps/bricklogger`, with a
 compose file for the daemon, the web interface and the MCP server; see
@@ -59,9 +61,9 @@ Bricklogger creates and migrates its own tables at the first start.
 ## First setup
 
 ```bash
-bricklogger init                        # guided: sources, destinations, secrets
+bricklogger init                        # guided: sources, destinations, secrets, services
 bricklogger validate                    # after any edit by hand
-bricklogger daemon start                # or: sudo systemctl enable --now bricklogger
+bricklogger services install --web      # if init did not: the daemon and the web interface
 bricklogger model upload building.ttl   # validate, infer, activate
 bricklogger status
 bricklogger points --outcome active     # the last value of every point
@@ -70,17 +72,17 @@ bricklogger points --outcome active     # the last value of every point
 `init` asks for the settings of each source and destination and writes four
 files: `sources.yaml`, `destinations.yaml`, `rules.yaml` and `daemon.yaml`.
 Secrets, such as the database password, go into an `env` file beside them and
-are referred to as `${NAME}`. The first rule set accepts every point in the
+are referred to as `${NAME}`. Last, `init` offers to run the daemon — and the
+web interface and the MCP server, if you want them — as `systemd --user`
+services that start at boot. The first rule set accepts every point in the
 model every five minutes; [rules](https://cx1-aps.github.io/bricklogger/features/configuration/)
 narrow that down by class, location, equipment or any SPARQL pattern.
 
 ## The web interface and an assistant
 
-```bash
-bricklogger serve        # http://127.0.0.1:8421
-```
-
-Everything the CLI does can be done there, and the model explorer shows the
+The web interface is at `http://127.0.0.1:8421` once its service runs, or
+after `bricklogger serve` in a terminal. Everything the CLI does can be done
+there, and the model explorer shows the
 building as a tree and a graph, with every point's outcome and value.
 
 To let an AI assistant that speaks MCP set up sources, destinations and rules,
@@ -100,7 +102,7 @@ before it writes, and never takes a secret's value. See
 bricklogger plugins                          # what is installed
 bricklogger plugins add bricklogger-ibos     # add a plugin from PyPI
 bricklogger plugins remove ibos              # remove one by its type
-sudo systemctl restart bricklogger           # the daemon reads plugins at start
+systemctl --user restart bricklogger         # the daemon reads plugins at start
 ```
 
 A plugin is a Python package that provides a source or a destination type. A
@@ -124,14 +126,26 @@ See [notifications](https://cx1-aps.github.io/bricklogger/features/notifications
 
 ```bash
 bricklogger update status        # what there is to upgrade
-sudo bricklogger update all      # Bricklogger and the plugins together
+bricklogger update all           # Bricklogger and the plugins together
 ```
 
 `update` checks the configuration with the new version before it restarts
 anything, and puts the previous versions back if it does not hold; the
 configuration and the data stay where they are. `update core` upgrades
-Bricklogger alone, `update <type>` one plugin. Running the install script
-again works too. A container pulls the new image instead.
+Bricklogger alone, `update <type>` one plugin. Do not run
+`uv tool install bricklogger` again over an installation with plugins: it
+uninstalls every plugin not named with `--with`. A container pulls the new
+image instead.
+
+**Upgrading from 0.2 installed with the install script:** the install script
+is gone, and so is installing as root. Remove the old installation with the
+script it came from — `curl -fsSL
+https://github.com/CX1-ApS/bricklogger/releases/download/v0.2.2/install.sh |
+sudo sh -s -- --uninstall`, without `sudo` for one in a home directory — then
+install as above, add the plugins again with `bricklogger plugins add`, copy
+the configuration, its `env` file and the data over if they lay in
+`/etc/bricklogger` and `/var/lib/bricklogger` — with `data_dir` in
+`daemon.yaml` changed to the new place — and run `bricklogger services install`.
 
 **Upgrading from 0.1 with an iBOS source:** iBOS is no longer built in. The
 `ibos` instance shows as failed until the plugin is added with

{bricklogger-0.2.2 → bricklogger-0.2.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "bricklogger"
-version = "0.2.2"
+version = "0.2.3"
 description = "Data bridge for building automation: collects data based on a Brick model and writes it to time-series databases"
 readme = "README.md"
 license = "MIT"

{bricklogger-0.2.2 → bricklogger-0.2.3}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "bricklogger"
-version = "0.2.2"
+version = "0.2.3"
 description = "Data bridge for building automation: collects data based on a Brick model and writes it to time-series databases"
 readme = "README.md"
 license = "MIT"

{bricklogger-0.2.2 → bricklogger-0.2.3}/src/bricklogger/__init__.py

@@ -14,4 +14,4 @@ The package is laid out after the architecture in ``docs/architecture.md``:
   external plugins.
 """
 
-__version__ = "0.2.2"
+__version__ = "0.2.3"

{bricklogger-0.2.2 → bricklogger-0.2.3}/src/bricklogger/cli/__init__.py

@@ -24,6 +24,7 @@ from bricklogger.cli.plugins import plugins_app
 from bricklogger.cli.query import query_command
 from bricklogger.cli.roles import destinations_app, sources_app
 from bricklogger.cli.serve import serve_command
+from bricklogger.cli.services import services_app
 from bricklogger.cli.update import update_app
 from bricklogger.config import resolve_config_dir
 
@@ -49,7 +50,7 @@ def _root(
         typer.Option(
             "--config-dir",
             help="The config directory; default $BRICKLOGGER_CONFIG_DIR, "
-            "then /etc/bricklogger when it exists, then ~/.config/bricklogger.",
+            "then ~/.config/bricklogger.",
             show_default=False,
         ),
     ] = None,
@@ -92,6 +93,7 @@ app.command("validate")(validate_command)
 app.command("status")(status_command)
 app.command("points")(points_command)
 app.add_typer(daemon_app, name="daemon")
+app.add_typer(services_app, name="services")
 app.add_typer(sources_app, name="sources")
 app.add_typer(destinations_app, name="destinations")
 app.add_typer(rules_app, name="rules")

{bricklogger-0.2.2 → bricklogger-0.2.3}/src/bricklogger/cli/init.py

@@ -2,9 +2,10 @@
 
 In a terminal it is a guided setup — which sources and destinations, a name
 and the settings of each from the plugin's own schema, secrets straight into
-the ``env`` file — and ``--non-interactive`` writes the four files with
-commented examples instead. Either way it refuses to overwrite a file that
-exists, so it can never destroy a configuration.
+the ``env`` file, and last the offer to set up the services — and
+``--non-interactive`` writes the four files with commented examples instead.
+Either way it refuses to overwrite a file that exists, so it can never destroy
+a configuration.
 """
 
 from __future__ import annotations
@@ -19,6 +20,7 @@ from bricklogger.cli.config import registry, report_validation
 from bricklogger.cli.context import CliContext, cli_context
 from bricklogger.cli.guided import ask_settings, write_env
 from bricklogger.cli.output import fail
+from bricklogger.cli.services import install as install_services
 from bricklogger.config import (
     CONFIG_FILES,
     RESERVED_INSTANCE_NAMES,
@@ -31,6 +33,7 @@ from bricklogger.config import (
     write_examples,
     write_text,
 )
+from bricklogger.ops import services
 from bricklogger.sdk.declaration import DestinationDeclaration, SourceDeclaration
 
 NonInteractiveFlag = Annotated[
@@ -102,8 +105,7 @@ def _guided(context: CliContext) -> None:
             write_text(config_dir, "destinations", destinations),
             write_text(config_dir, "rules", examples["rules"]),
         ]
-        if secrets:
-            written.append(write_env(config_dir, secrets))
+        written.append(write_env(config_dir, secrets))
     except OSError as exc:
         raise fail(f"could not write to {config_dir}: {exc}") from exc
     typer.echo("")
@@ -119,12 +121,33 @@ def _guided(context: CliContext) -> None:
         where=str(config_dir),
     )
     typer.echo("")
-    typer.echo("Next: start the daemon and upload the model.")
-    typer.echo("  bricklogger daemon start   (or: systemctl enable --now bricklogger)")
+    started = _offer_services(context)
+    typer.echo("")
+    if started:
+        typer.echo("Next: upload the model.")
+    else:
+        typer.echo("Next: start the daemon and upload the model.")
+        typer.echo("  bricklogger daemon start")
     typer.echo("  bricklogger model upload <model.ttl>")
     typer.echo("  bricklogger status")
 
 
+def _offer_services(context: CliContext) -> bool:
+    """Ask whether to set up the services, and do it on a yes; whether the
+    daemon now runs as one. Nothing is asked where they cannot be set up."""
+    if services.refusal(services.this_host(), context.config_dir) is not None:
+        return False
+    if not typer.confirm(
+        "Set up the services now? The daemon then starts at boot", default=True
+    ):
+        typer.echo("The same later: bricklogger services install [--web] [--mcp]")
+        return False
+    web = typer.confirm("  Also the web interface?", default=True)
+    mcp = typer.confirm("  Also the MCP server over HTTP?", default=False)
+    install_services(context.config_dir, web=web, mcp=mcp)
+    return True
+
+
 def _collect(
     role: str,
     file: str,

{bricklogger-0.2.2 → bricklogger-0.2.3}/src/bricklogger/cli/mcp_command.py

@@ -208,27 +208,28 @@ def _restart_line(before: dict[str, object], restart: bool) -> str:
         )
     if _restart_unit(command, str(before["url"]).removesuffix("/mcp")):
         return f"restarted {UNIT}; the new token is in effect"
-    return f"{UNIT} was restarted but does not answer yet; check it with systemctl"
+    return (
+        f"{UNIT} was restarted but does not answer yet; check it with "
+        f"systemctl --user status {UNIT}"
+    )
 
 
 def _systemctl() -> list[str] | None:
-    """The systemctl that has the MCP unit active, system or user; else ``None``."""
+    """The login's systemctl when it has the MCP unit active; else ``None``."""
     if shutil.which("systemctl") is None:
         return None
-    for command in (["systemctl"], ["systemctl", "--user"]):
-        try:
-            answer = subprocess.run(
-                [*command, "is-active", UNIT],
-                capture_output=True,
-                text=True,
-                timeout=5,
-                check=False,
-            )
-        except (OSError, subprocess.SubprocessError):
-            continue
-        if answer.stdout.strip() == "active":
-            return command
-    return None
+    command = ["systemctl", "--user"]
+    try:
+        answer = subprocess.run(
+            [*command, "is-active", UNIT],
+            capture_output=True,
+            text=True,
+            timeout=5,
+            check=False,
+        )
+    except (OSError, subprocess.SubprocessError):
+        return None
+    return command if answer.stdout.strip() == "active" else None
 
 
 def _restart_unit(command: list[str], url: str, timeout: float = 15.0) -> bool:
@@ -282,7 +283,7 @@ def _server_line(settings: DaemonSettings, token: str | None) -> str:
         return f"server: running at {url} — accepts this token"
     return (
         f"server: running at {url} — rejects this token; restart it, "
-        f"e.g. systemctl restart {UNIT}"
+        f"e.g. systemctl --user restart {UNIT}"
     )
 
 

{bricklogger-0.2.2 → bricklogger-0.2.3}/src/bricklogger/cli/plugins.py

@@ -155,9 +155,8 @@ def _restart_note() -> None:
     if plugin_directory() is not None:
         typer.echo("  docker compose restart daemon      (in a container)")
     else:
-        typer.echo(
-            "  bricklogger daemon restart      (or: systemctl restart bricklogger)"
-        )
+        typer.echo("  systemctl --user restart bricklogger   (a service)")
+        typer.echo("  bricklogger daemon restart             (started by hand)")
     typer.echo(
         "The MCP server over HTTP reads them the same way; the web interface "
         "needs nothing."

bricklogger-0.2.3/src/bricklogger/cli/services.py

@@ -0,0 +1,102 @@
+"""``bricklogger services``: the daemon, the web interface and the MCP server as
+``systemd --user`` units of the login. See ``docs/features/cli.md``,
+"services"."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from rich.table import Table
+
+from bricklogger.cli.context import cli_context
+from bricklogger.cli.output import fail, print_json, stdout
+from bricklogger.ops import services
+from bricklogger.ops.errors import OperationError
+
+services_app = typer.Typer(
+    no_args_is_help=True,
+    help="Run the daemon, the web interface and the MCP server as systemd --user "
+    "services of this login, started at boot.",
+)
+
+WebFlag = Annotated[bool, typer.Option("--web", help="The web interface.")]
+McpFlag = Annotated[bool, typer.Option("--mcp", help="The MCP server over HTTP.")]
+
+
+@services_app.command("install")
+def install_command(
+    ctx: typer.Context, web: WebFlag = False, mcp: McpFlag = False
+) -> None:
+    """Set up the daemon as a service, and the web interface and the MCP server
+    when their flag is given; enable lingering, and start what was written.
+
+    Can be run again: a flag adds its unit and leaves the others as they are.
+    """
+    install(cli_context(ctx).config_dir, web=web, mcp=mcp)
+
+
+def install(config_dir: Path, *, web: bool, mcp: bool) -> None:
+    """``services install``, and what ``init`` runs when it is told yes."""
+    try:
+        result = services.install(config_dir=config_dir, web=web, mcp=mcp)
+    except OperationError as exc:
+        raise fail(exc.message) from exc
+    if result.written:
+        typer.echo(f"wrote {', '.join(result.written)} in {result.unit_dir}")
+    if result.started:
+        typer.echo(f"started {', '.join(result.started)}")
+    if result.restarted:
+        typer.echo(f"restarted {', '.join(result.restarted)} with the new unit")
+    if not (result.written or result.started or result.restarted):
+        typer.echo(f"{', '.join(result.units)} already set up and running")
+    if result.linger_command is not None:
+        typer.echo(
+            "lingering could not be enabled, so the services stop at logout and do "
+            "not start at boot; enable it once with:"
+        )
+        typer.echo(f"  {result.linger_command}")
+
+
+@services_app.command("uninstall")
+def uninstall_command(web: WebFlag = False, mcp: McpFlag = False) -> None:
+    """Stop, disable and remove the services: all of them without a flag, the
+    ones named with one. The configuration and the data stay."""
+    try:
+        result = services.uninstall(web=web, mcp=mcp)
+    except OperationError as exc:
+        raise fail(exc.message) from exc
+    if result.removed:
+        typer.echo(f"removed {', '.join(result.removed)}")
+    else:
+        typer.echo("no service was set up")
+
+
+@services_app.command("status")
+def status_command(
+    json_output: Annotated[
+        bool, typer.Option("--json", help="Emit JSON instead of a table.")
+    ] = False,
+) -> None:
+    """For each unit: written, enabled and active; and whether lingering is on."""
+    state = services.status()
+    if json_output:
+        print_json(state.as_dict())
+        return
+    table = Table(box=None)
+    for column in ("Unit", "Written", "Enabled", "Active"):
+        table.add_column(column)
+    for unit in state.units:
+        table.add_row(
+            unit.name, _word(unit.written), _word(unit.enabled), _word(unit.active)
+        )
+    stdout.print(table)
+    if not state.systemd:
+        typer.echo("systemctl --user does not answer on this machine")
+    else:
+        typer.echo(f"lingering: {_word(state.linger)}")
+
+
+def _word(value: bool | None) -> str:
+    return "?" if value is None else "yes" if value else "no"

{bricklogger-0.2.2 → bricklogger-0.2.3}/src/bricklogger/cli/update.py

@@ -1,7 +1,7 @@
 """``bricklogger update``: what there is to upgrade, and the upgrade itself.
 
 ``update status`` installs nothing. ``update core``, ``update all`` and
-``update TYPE`` upgrade from PyPI with the environment's own uv, validate with
+``update TYPE`` upgrade from PyPI with ``uv tool install``, validate with
 the new version, put the previous versions back when that fails, write the
 units again and restart what runs as a unit. ``update`` alone shows this help,
 as every group does. See ``docs/features/cli.md``, "update".
@@ -168,7 +168,7 @@ def _report(result: Updated, target: str, no_restart: bool) -> None:
     for unit in result.not_answering:
         typer.echo(
             f"{unit} was restarted but does not answer yet; check its log with "
-            f"journalctl -u {unit}"
+            f"journalctl --user -u {unit}"
         )
     for note in result.notes:
         typer.echo(note)

{bricklogger-0.2.2 → bricklogger-0.2.3}/src/bricklogger/config/loader.py

@@ -30,7 +30,7 @@ CONFIG_FILES: tuple[str, ...] = ("daemon", "sources", "destinations", "rules")
 """The four files, by name without extension, in the order they are reported."""
 
 SYSTEM_CONFIG_DIR = Path("/etc/bricklogger")
-"""The config directory of a machine-wide installation."""
+"""The config directory in the container, which names it with the variable."""
 
 SYSTEM_DATA_DIR = Path("/var/lib/bricklogger")
 """The data directory that belongs to it."""
@@ -58,22 +58,21 @@ def resolve_config_dir(
     env: Mapping[str, str] | None = None,
     home: Path | None = None,
 ) -> Path:
-    """The flag, then the environment variable, then the system directory when it
-    exists, then the one in the home directory."""
+    """The flag, then the environment variable, then the one in the home
+    directory."""
     if cli_value is not None:
         return cli_value
     environment = os.environ if env is None else env
     from_env = environment.get(CONFIG_DIR_ENV)
     if from_env:
         return Path(from_env)
-    if SYSTEM_CONFIG_DIR.is_dir():
-        return SYSTEM_CONFIG_DIR
     return user_config_dir(home)
 
 
 def default_data_dir(config_dir: Path, home: Path | None = None) -> Path:
-    """Where the data goes when ``daemon.yaml`` does not say: beside a system
-    configuration in ``/var/lib``, otherwise in the home directory."""
+    """Where the data goes when ``daemon.yaml`` does not say: beside the
+    container's configuration in ``/var/lib``, otherwise in the home
+    directory."""
     return SYSTEM_DATA_DIR if config_dir == SYSTEM_CONFIG_DIR else user_data_dir(home)
 
 

{bricklogger-0.2.2 → bricklogger-0.2.3}/src/bricklogger/docs/architecture.md

@@ -805,8 +805,8 @@ the runtime state, and **the spools** of the destinations.
 
 ## Platform
 
-Bricklogger runs in production on **Linux**. Filesystem defaults such as
-`/etc/bricklogger` and `/var/lib/bricklogger` for a service, with
-`~/.config/bricklogger` and `~/.local/share/bricklogger` for a run without
-root, the install script and the choice of OWL-RL reasoner follow from
-that.
+Bricklogger runs in production on **Linux**. The filesystem defaults —
+`~/.config/bricklogger` and `~/.local/share/bricklogger` for the login that
+runs it, `/etc/bricklogger` and `/var/lib/bricklogger` in the container — the
+installation with `uv tool install` and `systemd --user` services, and the
+choice of OWL-RL reasoner follow from that.

{bricklogger-0.2.2 → bricklogger-0.2.3}/src/bricklogger/docs/docker.md

@@ -1,11 +1,11 @@
 # Docker
 
-Bricklogger also runs as a container. The image holds the same program the
-[install script](getting-started.md#install) installs — the same commands, the
-same four configuration files, the same directories — so a host where
-everything else is a container needs nothing else installed. The install
-script remains the primary installation; the image is the second way, and
-neither changes how Bricklogger works.
+Bricklogger also runs as a container. The image holds the same program
+[`uv tool install`](getting-started.md#install) installs — the same commands
+and the same four configuration files — so a host where everything else is a
+container needs nothing else installed. The installation with uv remains the
+primary one; the image is the second way, and neither changes how
+Bricklogger works.
 
 ## The image
 
@@ -14,16 +14,16 @@ published by GitHub Actions.
 
 | Tag | What it is |
 |-----|------------|
-| `0.2.2` | One released version — what a building's logger should name |
+| `0.2.3` | One released version — what a building's logger should name |
 | `0.2` | The newest patch of that minor version |
 | `latest` | The newest release |
 
 Every version is built for `linux/amd64` and `linux/arm64`, and only after the
 test suite has passed.
 
-Inside, the layout is the one a service install gives: the Python environment
-under `/opt/bricklogger`, the `bricklogger` command on the path, the
-configuration in `/etc/bricklogger`, the data in `/var/lib/bricklogger`. All
+Inside, the Python environment is under `/opt/bricklogger`, the
+`bricklogger` command on the path, the configuration in `/etc/bricklogger` —
+named by `BRICKLOGGER_CONFIG_DIR` — and the data in `/var/lib/bricklogger`. All
 of it belongs to an unprivileged user, and the container runs as that user and
 never as root.
 
@@ -55,7 +55,7 @@ name: bricklogger
 
 services:
   daemon:
-    image: ghcr.io/cx1-aps/bricklogger:0.2.2
+    image: ghcr.io/cx1-aps/bricklogger:0.2.3
     network_mode: host
     restart: unless-stopped
     stop_grace_period: 30s
@@ -65,7 +65,7 @@ services:
       - plugins:/var/lib/bricklogger/plugins
 
   web:
-    image: ghcr.io/cx1-aps/bricklogger:0.2.2
+    image: ghcr.io/cx1-aps/bricklogger:0.2.3
     command: ["bricklogger", "serve"]
     profiles: ["web"]
     depends_on: ["daemon"]
@@ -77,7 +77,7 @@ services:
       - plugins:/var/lib/bricklogger/plugins
 
   mcp:
-    image: ghcr.io/cx1-aps/bricklogger:0.2.2
+    image: ghcr.io/cx1-aps/bricklogger:0.2.3
     command: ["bricklogger", "mcp", "serve", "--http"]
     profiles: ["mcp"]
     depends_on: ["daemon"]
@@ -357,7 +357,7 @@ docker run -d --name bricklogger \
   -v bricklogger-config:/etc/bricklogger \
   -v bricklogger-data:/var/lib/bricklogger \
   -v bricklogger-plugins:/var/lib/bricklogger/plugins \
-  ghcr.io/cx1-aps/bricklogger:0.2.2
+  ghcr.io/cx1-aps/bricklogger:0.2.3
 ```
 
 The web interface and the MCP server are two more `docker run` lines with the