Files
pipelines/scripts/setup-docker.py
T

163 lines
8.9 KiB
Python

#!/usr/bin/env python3
"""Configure, authenticate and verify the full Docker installation."""
import argparse
import importlib.util
import ipaddress
import json
from pathlib import Path
import subprocess
import sys
def module(name, file):
spec = importlib.util.spec_from_file_location(name, Path(__file__).with_name(file))
result = importlib.util.module_from_spec(spec)
spec.loader.exec_module(result)
return result
configure = module("configure_compose", "configure-compose.py")
tokens = module("save_ntfy_token", "save-ntfy-token.py")
lan = module("lan_address", "lan-address.py")
class Setup:
def __init__(self, directory, runner=subprocess.run):
self.directory = Path(directory)
self.runner = runner
def compose(self, *args, capture=False, check=True, **kwargs):
result = self.runner(["docker", "compose", *args], cwd=self.directory,
capture_output=capture, text=True, **kwargs)
if check and result.returncode:
# Captured ntfy output may contain tokens. Never replay it on failure.
raise ValueError(f"Docker setup step failed (exit {result.returncode}); no credentials were replaced")
return result
def settings(self, args):
settings = self.directory / ".env"
bind = str(ipaddress.IPv4Address(args.bind_address or "0.0.0.0"))
if settings.is_symlink():
raise ValueError("Refusing to modify a symlinked .env")
if settings.exists():
if any((args.ntfy_url, args.timezone, args.port)):
raise ValueError(".env already exists; edit it explicitly rather than replace existing configuration")
text = settings.read_text()
for key, value in (("NTFY_BIND_ADDRESS", bind),
("PIPELINES_BIND_ADDRESS", "0.0.0.0")):
if any(line.startswith(key + "=") for line in text.splitlines()):
text = "".join(key + "=" + value + "\n" if line.startswith(key + "=") else line
for line in text.splitlines(keepends=True))
else:
text = text.rstrip("\n") + "\n" + key + "=" + value + "\n"
if text != settings.read_text():
settings.write_text(text)
print(f"Docker binds: ntfy {bind}, Pipelines 0.0.0.0; existing URLs, timezone, ports and credentials retained.")
return
address = lan.detect_lan() if not args.ntfy_url else None
url = args.ntfy_url or f"http://{address}:8090"
timezone = args.timezone
if not timezone:
try:
timezone = configure.host_timezone()
except ValueError:
timezone = "UTC"
print("Host timezone unavailable; using UTC (override with --timezone if needed).")
configure.configure(self.directory, url, bind, timezone, args.port or 8081)
print(f"LAN notifications configured: {url} (bind {bind}; authentication required).")
print("Use this address on your phone on the same trusted LAN; do not forward this HTTP port to the Internet.")
def bootstrap_ntfy(self):
token = self.directory / "secrets/ntfy-token.txt"
if token.is_symlink():
raise ValueError("Refusing a symlink for the publishing token")
if token.exists() and token.stat().st_size:
print("Keeping existing ntfy publishing token.")
else:
print("Set a password for ntfy's pipeline-publisher account (not a model-provider account).")
self.compose("exec", "ntfy", "ntfy", "user", "add", "--ignore-exists", "pipeline-publisher")
self.compose("exec", "-T", "ntfy", "ntfy", "access", "pipeline-publisher", "pipelines", "write-only")
result = self.compose("exec", "-T", "ntfy", "ntfy", "token", "add", "pipeline-publisher", capture=True)
tokens.save_token(result.stdout + result.stderr, self.directory)
# --ignore-exists preserves the phone account's password on re-install.
print("Set the phone-reader password if this is a new ntfy account; existing accounts are preserved.")
self.compose("exec", "ntfy", "ntfy", "user", "add", "--ignore-exists", "phone-reader")
self.compose("exec", "-T", "ntfy", "ntfy", "access", "phone-reader", "pipelines", "read-only")
def authenticate(self, relogin=False):
def connected():
result = self.compose("run", "--rm", "--no-deps", "-T", "--entrypoint", "opencode",
"pipelines", "auth", "list", "--format", "json", capture=True)
accounts = json.loads(result.stdout)
if not isinstance(accounts, list):
raise ValueError("Unexpected OpenCode account-list format; authentication not verified")
return any(isinstance(account, dict) and account.get("connections") for account in accounts)
if connected() and not relogin:
print("Keeping existing OpenCode provider setup in its Docker volume.")
return
print("Choose and authenticate your provider in the container's OpenCode login below.")
self.compose("run", "--rm", "--no-deps", "--entrypoint", "opencode", "pipelines", "auth", "login")
if not connected():
raise ValueError("Provider setup incomplete; rerun the installer to continue (credentials/volumes retained)")
def verify(self):
# Read the token inside the container; never put it in argv or output.
probe = '''set -eu
test -s "$PIPELINES_NTFY_TOKEN_FILE"
printf 'header = "Authorization: Bearer %s"\\n' "$(cat "$PIPELINES_NTFY_TOKEN_FILE")" |
curl --config - --fail --silent --show-error --max-time 10 --output /dev/null \
--data 'Pipelines Docker setup: authenticated publishing verified.' "$PIPELINES_NTFY_URL"
'''
self.compose("exec", "-T", "pipelines", "sh", "-c", probe, capture=True)
result = self.compose("exec", "-T", "pipelines", "pipelines", "--url",
"ws://127.0.0.1:8080/connect", "status", "--json", capture=True)
status = json.loads(result.stdout)
if (status.get("ntfy", {}).get("health") != "healthy"
or not status.get("ntfy", {}).get("url") or status.get("topic") != "pipelines"):
raise ValueError("Pipelines did not report healthy ntfy; check docker compose logs pipelines ntfy")
print("Verified: Pipelines reports healthy ntfy and authenticated publishing succeeded.")
print(f"On your phone: add {status['ntfy']['url']}, log in as phone-reader, subscribe to pipelines.")
print("Phone delivery and model inference are not verified by this setup check.")
address = self.compose("port", "pipelines", "8080", capture=True).stdout.strip()
port = address.rsplit(":", 1)[-1]
if not port.isdigit():
raise ValueError("Could not identify the published Pipelines port")
print(f"Host CLI/TUI connection: pipelines --url ws://127.0.0.1:{port}/connect tui")
print("Install host client binaries with ./install.sh --native if needed.")
def run(self, args):
self.compose("version", capture=True)
self.settings(args)
# Validate the actual resolved Compose configuration before starting anything.
self.compose("config", "--quiet", capture=True)
self.compose("up", "-d", "--wait", "--wait-timeout", "60", "ntfy")
self.bootstrap_ntfy()
self.compose("build", "pipelines")
self.compose("run", "--rm", "--no-deps", "-T", "--entrypoint", "pipelines", "pipelines", "skill", "install")
self.authenticate(args.relogin)
# Recreate to reload file secrets and environment, without deleting volumes.
self.compose("up", "-d", "--force-recreate", "--wait", "--wait-timeout", "60", "pipelines")
self.verify()
print("Docker setup complete. Use docker compose ps / logs to manage it; no OS user service was registered.")
def arguments(argv=None):
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("--ntfy-url", help="Override the auto-detected LAN ntfy address")
parser.add_argument("--bind-address", help="Override ntfy's default 0.0.0.0 bind address")
parser.add_argument("--timezone", help="Override the detected timezone (fallback: UTC)")
parser.add_argument("--port", type=int)
parser.add_argument("--relogin", action="store_true", help="open OpenCode provider login again without deleting accounts")
return parser.parse_args(argv)
if __name__ == "__main__":
try:
Setup(Path(__file__).resolve().parents[1]).run(arguments())
except KeyboardInterrupt:
print("\nSetup canceled; existing configuration, credentials and Docker volumes were retained.", file=sys.stderr)
sys.exit(130)
except (ValueError, OSError, EOFError, json.JSONDecodeError, configure.ZoneInfoNotFoundError) as error:
sys.exit(f"Docker setup incomplete: {error}")