Files
pipelines/scripts/install.py
T

307 lines
17 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
#!/usr/bin/env python3
"""Install a clean native Pipelines service and authenticated Docker ntfy."""
import argparse
import getpass
import hashlib
import importlib.util
import json
import os
from pathlib import Path
import platform
import plistlib
import re
import secrets
import shutil
import socket
import subprocess
import sys
from manage import DEFAULT_PREFIX, MARKER, compose, load, run, start, wait_health
SOURCE = Path(__file__).resolve().parents[1]
NAME = re.compile(r"^[A-Za-z][A-Za-z0-9_-]{0,63}$")
TOPIC = re.compile(r"^[-_A-Za-z0-9]{1,64}$")
def choose_port(preferred):
for port in range(preferred, min(preferred + 100, 65536)):
with socket.socket() as sock:
try:
sock.bind(("0.0.0.0", port))
return port
except OSError:
pass
raise ValueError("No available local service port")
def default_host():
tailscale = shutil.which("tailscale")
if tailscale:
try:
data = json.loads(run([tailscale, "status", "--json"], quiet=True, timeout=10).stdout)
if data.get("BackendState") == "Running":
return next(ip for ip in data["TailscaleIPs"] if ":" not in ip)
except (RuntimeError, ValueError, KeyError, StopIteration, subprocess.SubprocessError):
pass
with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as sock:
try:
sock.connect(("192.0.2.1", 80))
return sock.getsockname()[0]
except OSError:
return "127.0.0.1"
def timezone():
spec = importlib.util.spec_from_file_location("configure", SOURCE / "scripts/configure-compose.py")
module = importlib.util.module_from_spec(spec); spec.loader.exec_module(module)
return module.host_timezone()
def write_private(path, text):
path.parent.mkdir(parents=True, exist_ok=True, mode=0o700)
with path.open("x") as file:
file.write(text)
path.chmod(0o600)
def ntfy_compose(config):
# JSON scalars are valid YAML scalars and prevent interpolation/injection.
q = lambda value: json.dumps(str(value))
return f'''services:
ntfy:
image: binwiederhier/ntfy:v2.29.0
command: serve
restart: unless-stopped
environment:
TZ: {q(config['timezone'])}
NTFY_BASE_URL: {q(config['public_url'])}
NTFY_LISTEN_HTTP: ":80"
NTFY_CACHE_FILE: /var/lib/ntfy/cache.db
NTFY_CACHE_DURATION: 168h
NTFY_AUTH_FILE: /var/lib/ntfy/auth.db
NTFY_AUTH_DEFAULT_ACCESS: deny-all
NTFY_ENABLE_LOGIN: "true"
NTFY_ATTACHMENT_CACHE_DIR: /var/lib/ntfy/attachments
NTFY_ATTACHMENT_EXPIRY_DURATION: 168h
NTFY_ATTACHMENT_TOTAL_SIZE_LIMIT: 1G
NTFY_ATTACHMENT_FILE_SIZE_LIMIT: 1M
ports:
- "0.0.0.0:{config['ntfy_port']}:80"
volumes:
- ntfy-data:/var/lib/ntfy
volumes:
ntfy-data:
'''
def make_registration(config):
root = Path(config["prefix"])
command = [config["python"], str(root / "lib/manage.py"), "supervise", "--prefix", str(root)]
if platform.system() == "Darwin":
path = Path.home() / "Library/LaunchAgents" / (config["label"] + ".plist")
path.parent.mkdir(parents=True, exist_ok=True)
if path.exists():
raise ValueError("Service registration already exists; refusing to overwrite")
with path.open("wb") as file:
plistlib.dump({"Label": config["label"], "ProgramArguments": command,
"RunAtLoad": True, "KeepAlive": {"SuccessfulExit": False},
"ExitTimeOut": 75, "ThrottleInterval": 10,
"StandardOutPath": str(root / "logs/supervisor.log"),
"StandardErrorPath": str(root / "logs/supervisor.log")}, file)
else:
path = Path.home() / ".config/systemd/user" / (config["label"] + ".service")
path.parent.mkdir(parents=True, exist_ok=True)
if path.exists():
raise ValueError("Service registration already exists; refusing to overwrite")
# systemd quotes its own command arguments, not shell strings.
quote = lambda value: '"' + value.replace("\\", "\\\\").replace('"', '\\"').replace("%", "%%") + '"'
path.write_text("[Unit]\nDescription=Pipelines server and ntfy\nAfter=default.target\n\n"
"[Service]\nType=simple\nExecStart=" + " ".join(map(quote, command)) +
"\nRestart=on-failure\nRestartSec=10\nTimeoutStopSec=90\n\n[Install]\nWantedBy=default.target\n")
return str(path)
def install(args):
if platform.system() not in ("Darwin", "Linux"):
raise ValueError("Supported: macOS and Linux (run as your normal user, not root)")
if os.getuid() == 0:
raise ValueError("Do not use sudo: this install reuses your user's OpenCode account")
root = args.prefix.expanduser().resolve()
if root in (Path("/"), Path.home().resolve(), SOURCE):
raise ValueError("Choose a dedicated installation directory")
docker = shutil.which("docker")
if not docker:
raise ValueError("Install/start Docker Desktop or Docker Engine first")
run([docker, "info", "--format", "{{.ServerVersion}}"], quiet=True, timeout=15)
run([docker, "compose", "version"], quiet=True, timeout=15)
if (root / MARKER).exists() and not load(root).get("uninstalled"):
config = load(root)
if not config.get("bootstrapped"):
raise ValueError("A partial installation exists; inspect it or run uninstall.sh --prefix ... --purge before retrying")
start(config)
print(f"Existing installation started; settings/history preserved: {root}")
return
retained = load(root) if (root / MARKER).exists() else None
if root.exists() and any(root.iterdir()) and retained is None:
raise ValueError("Installation directory is not empty; refusing to overwrite unrelated files")
if not args.no_autostart and platform.system() == "Linux":
run(["systemctl", "--user", "show-environment"], quiet=True)
opencode = args.opencode or shutil.which("opencode") or shutil.which("opencode2")
if not opencode:
npm=shutil.which("npm")
if not npm:
raise ValueError("Install OpenCode V2 first (npm install -g @opencode/cli), or install npm for automatic CLI setup")
if not args.yes and input("OpenCode V2 is missing. Install its pinned CLI privately using npm? [Y/n] ").strip().lower()=="n":
raise ValueError("OpenCode installation canceled")
root.mkdir(parents=True,exist_ok=True,mode=0o700)
run([npm,"install","--prefix",str(root / "tools"),"@opencode/cli@2.0.20"],quiet=True,timeout=240)
opencode=str(root / "tools/node_modules/.bin/opencode")
opencode = str(Path(opencode).resolve())
version = run([opencode, "--version"], quiet=True, timeout=15).stdout
if not re.search(r"(?:^|\s)v?2\.\d+", version):
raise ValueError("OpenCode V2 is required; your existing login/config will be reused, never exported")
auth = run([opencode, "auth", "list"], quiet=True, timeout=30).stdout
if "OpenCode Go" not in auth:
if args.yes:
raise ValueError("Connect OpenCode Go first: opencode auth login")
print("OpenCode Go is not connected. Complete your existing OpenCode login now.")
subprocess.run([opencode, "auth", "login"], check=True)
auth = run([opencode, "auth", "list"], quiet=True, timeout=30).stdout
if "OpenCode Go" not in auth:
raise ValueError("OpenCode Go login not confirmed; installation canceled")
# This exercises discovery/start as the same user, without generating model output.
run([opencode, "api", "get", "/api/info"], quiet=True, timeout=30)
root.mkdir(parents=True, exist_ok=True, mode=0o700)
root.chmod(0o700)
for directory in ("bin", "lib", "data", "logs", "secrets", "workspace"):
(root / directory).mkdir(exist_ok=True, mode=0o700)
packaged = SOURCE / "release-bin"
if packaged.is_dir():
metadata = json.loads((packaged / "platform.json").read_text())
if metadata != {"os": platform.system(), "arch": platform.machine()}:
raise ValueError("Release archive is for a different OS/CPU")
for name in ("pipelines-server", "pipelines-tui", "pipelines"):
shutil.copy2(packaged / name, root / "bin" / name)
else:
go = shutil.which("go")
if not go:
raise ValueError("Source install needs Go 1.27+; alternatively use a platform release archive")
run([go, "install", "-trimpath", "./cmd/server", "./cmd/tui", "./cmd/pipelines"],
env=dict(os.environ, GOBIN=str(root / "bin")), quiet=True, timeout=240)
for command in ("server", "tui"):
(root / "bin" / command).replace(root / "bin" / ("pipelines-" + command))
username = retained["username"] if retained else (args.username or ("phone-reader" if args.yes else input("Phone username [phone-reader]: ").strip() or "phone-reader"))
topic = retained["topic"] if retained else (args.topic or ("pipelines" if args.yes else input("Notification topic [pipelines]: ").strip() or "pipelines"))
if not NAME.fullmatch(username) or username == "pipeline-publisher" or not TOPIC.fullmatch(topic):
raise ValueError("Use safe alphanumeric usernames/topics; pipeline-publisher is reserved")
server_port = retained["server_port"] if retained else choose_port(args.server_port)
ntfy_port = retained["ntfy_port"] if retained else choose_port(args.ntfy_port)
if server_port == ntfy_port:
ntfy_port = choose_port(ntfy_port + 1)
public_url = retained["public_url"] if retained else args.public_url or f"http://{default_host()}:{ntfy_port}"
from urllib.parse import urlparse
url = urlparse(public_url)
if url.scheme not in ("http", "https") or not url.hostname or url.username or url.password or url.path not in ("", "/") or url.query or url.fragment or any(c in public_url for c in "$\n\r\x00"):
raise ValueError("Phone URL must be an HTTP(S) base URL without credentials, topic, query, or interpolation")
chosen_workspace=args.workspace or (Path(retained["workspace"]) if retained else root / "workspace")
workspace = str(chosen_workspace.expanduser().resolve())
if not Path(workspace).is_dir():
raise ValueError("Workspace directory must exist")
suffix = hashlib.sha256(str(root).encode()).hexdigest()[:12]
bindir = Path("/usr/local/bin") if args.system_command else args.bin_dir.expanduser().resolve()
launcher = bindir / "pipelines"
if launcher.exists() or launcher.is_symlink():
if not launcher.is_symlink() or launcher.resolve() != root / "bin/pipelines":
raise ValueError("A pipelines command already exists in the target bin directory; choose --bin-dir")
# Only explicit server-selection variables are copied; never API keys/tokens.
opencode_env = {key: value for key, value in os.environ.items() if key in ("XDG_CONFIG_HOME", "XDG_DATA_HOME", "XDG_STATE_HOME", "OPENCODE_SERVER", "OPENCODE_DB")}
config = dict(format=1, prefix=str(root), docker=docker, python=sys.executable,
opencode=opencode, opencode_env=opencode_env, path=os.pathsep.join([str(root / "bin"), str(Path(opencode).parent), os.environ.get("PATH", "")]),
project="pipelines-" + suffix, label="io.pipelines." + suffix,
server_port=server_port, ntfy_port=ntfy_port, public_url=public_url.rstrip("/"),
topic=topic, username=username, timezone=timezone(), workspace=workspace,
workspace_roots=[str(path.expanduser().resolve()) for path in (args.workspace_root or ([Path(p) for p in retained["workspace_roots"]] if retained else [Path.home()]))],
launcher=str(launcher), registration=None, bootstrapped=bool(retained and retained.get("bootstrapped")))
manifest = root / MARKER
manifest.write_text(json.dumps(config, indent=2)); manifest.chmod(0o600)
(root / "compose.yaml").write_text(ntfy_compose(config))
shutil.copy2(SOURCE / "scripts/manage.py", root / "lib/manage.py")
alias = root / "bin/opencode"
if not alias.exists():
alias.symlink_to(opencode)
# The PATH command is the compiled Go binary, not a shell/Python launcher.
if not config["bootstrapped"]:
if args.password_file:
password = args.password_file.read_text().strip()
elif args.yes:
password = secrets.token_urlsafe(18)
else:
password = getpass.getpass("Phone password (blank = generate): ") or secrets.token_urlsafe(18)
if len(password) < 8 or any(c in password for c in "\r\n\x00"):
raise ValueError("Phone password must have at least 8 characters and no line breaks")
compose(config, "up", "-d", "ntfy", quiet=True)
wait_health(f"http://127.0.0.1:{ntfy_port}/v1/health")
for user, secret in (("pipeline-publisher", secrets.token_urlsafe(32)), (username, password)):
compose(config, "exec", "-T", "-e", "NTFY_PASSWORD", "ntfy", "ntfy", "user", "add", user,
env=dict(os.environ, NTFY_PASSWORD=secret), quiet=True)
compose(config, "exec", "-T", "ntfy", "ntfy", "access", "pipeline-publisher", topic, "write-only", quiet=True)
compose(config, "exec", "-T", "ntfy", "ntfy", "access", username, topic, "read-only", quiet=True)
output = compose(config, "exec", "-T", "ntfy", "ntfy", "token", "add", "pipeline-publisher", quiet=True).stdout
tokens = re.findall(r"\btk_[A-Za-z0-9]{29}\b", output)
if len(tokens) != 1:
raise RuntimeError("Could not extract the publishing token; credentials were not printed")
write_private(root / "secrets/publisher-token", tokens[0] + "\n")
write_private(root / "secrets/phone-login.txt", f"Server: {public_url}\nTopic: {topic}\nUsername: {username}\nPassword: {password}\n")
config["bootstrapped"] = True
if not args.no_autostart:
config["registration"] = make_registration(config)
manifest.write_text(json.dumps(config, indent=2))
if args.system_command and not bindir.exists():
subprocess.run(["sudo", "mkdir", "-p", str(bindir)], check=True)
else:
bindir.mkdir(parents=True, exist_ok=True)
if not launcher.is_symlink():
if args.system_command and not os.access(bindir, os.W_OK):
# Privilege is used ONLY for this command symlink, never for the server/auth.
subprocess.run(["sudo", "ln", "-s", str(root / "bin/pipelines"), str(launcher)], check=True)
else:
launcher.symlink_to(root / "bin/pipelines")
start(config)
print(f"Installed. Run: {launcher}\nManage both services: pipelines start|stop|restart|status|doctor|logs")
print(f"Phone server: {config['public_url']}\nTopic: {topic}\nUsername: {username}")
print(f"Password is private: {root / 'secrets/phone-login.txt'}")
print("Fresh installations have no pipelines. In the TUI press b for rendered examples/templates.")
print("ntfy is exposed on LAN/VPN with authentication. Use HTTPS or an encrypted VPN outside a trusted LAN.")
if str(bindir) not in os.environ.get("PATH", "").split(os.pathsep):
print(f"Add {bindir} to PATH, or use the full command path above.")
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("--prefix", type=Path, default=DEFAULT_PREFIX)
parser.add_argument("--bin-dir", type=Path, default=Path.home() / ".local/bin")
parser.add_argument("--system-command",action="store_true",help="Put the command in /usr/local/bin (sudo only for the symlink; services remain per-user)")
parser.add_argument("--username")
parser.add_argument("--topic")
parser.add_argument("--password-file", type=Path)
parser.add_argument("--public-url")
parser.add_argument("--workspace", type=Path)
parser.add_argument("--workspace-root",type=Path,action="append",help="Allowed repository root; repeatable (default: your home)")
parser.add_argument("--opencode", help="Path to the host OpenCode V2 CLI")
parser.add_argument("--server-port", type=int, default=8080)
parser.add_argument("--ntfy-port", type=int, default=8090)
parser.add_argument("--no-autostart", action="store_true", help="Use a managed background process rather than launchd/systemd")
parser.add_argument("--yes", action="store_true", help="Accept defaults and generate a private phone password")
args = parser.parse_args()
if not 1024 <= args.server_port <= 65535 or not 1024 <= args.ntfy_port <= 65535:
parser.error("Use unprivileged ports 1024–65535")
os.chdir(SOURCE)
install(args)
if __name__ == "__main__":
try:
main()
except (ValueError, RuntimeError, OSError, subprocess.SubprocessError) as error:
sys.exit(str(error))