Files
pipelines/scripts/manage.py
T

574 lines
25 KiB
Python

#!/usr/bin/env python3
"""One per-user lifecycle for the server, authenticated web proxy and ntfy."""
import argparse
import fcntl
import json
import os
from pathlib import Path
import platform
import plistlib
import re
import shutil
import signal
import subprocess
import sys
import time
import urllib.request
DEFAULT_PREFIX = Path.home() / ".local/share/pipelines"
MARKER = "pipelines-install.json"
SERVICE_MARKER = "Managed by Pipelines native installer"
def ntfy_mode(config):
"""Native ntfy is selected by the manifest; absent/explicit docker uses Compose."""
return (config.get("ntfy") or {}).get("mode", "docker")
def ntfy_health_url(config):
return f"http://127.0.0.1:{config['ntfy_port']}/v1/health"
def server_address(config):
"""The -addr the server binds.
The bind address is a manifest setting so the phone client can reach the
server over the LAN; manifests written before it existed default to loopback.
"""
return f"{config.get('bind_address') or '127.0.0.1'}:{config['server_port']}"
def server_token_env(config):
"""PIPELINES_SERVER_TOKEN_FILE for the server, the web proxy and the CLI."""
path = (config.get("web") or {}).get("server_token_file")
return {"PIPELINES_SERVER_TOKEN_FILE": path} if path else {}
def mdns_args(config):
"""The LAN port the server advertises over mDNS.
LAN clients dial the authenticated web proxy, not the loopback server, so
the proxy's port is advertised when the proxy listens beyond loopback.
"""
web = config.get("web") or {}
if web.get("port") and web.get("host") not in (None, "", "127.0.0.1", "localhost", "::1"):
return ["-mdns-port", str(web["port"])]
return []
def load(prefix):
prefix = Path(prefix).expanduser().resolve()
path = prefix / MARKER
if not path.is_file() or path.is_symlink() or path.stat().st_uid != os.getuid():
raise ValueError("Not a managed Pipelines installation owned by this user")
config = json.loads(path.read_text())
if config.get("format") != 1 or config.get("prefix") != str(prefix):
raise ValueError("Invalid installation manifest; refusing to manage paths")
return config
def run(args, *, env=None, quiet=False, check=True, timeout=120):
result = subprocess.run(args, env=env, capture_output=True, text=True, timeout=timeout)
if check and result.returncode:
# No subprocess output here: ntfy token/password commands may contain secrets.
raise RuntimeError(f"Command failed ({result.returncode}): {args[0]} {args[1] if len(args)>1 else ''}")
if not quiet and result.stdout:
print(result.stdout.rstrip())
return result
def compose(config, *args, **kwargs):
return run([config["docker"], "compose", "--project-name", config["project"],
"--file", str(Path(config["prefix"]) / "compose.yaml"), *args], **kwargs)
def healthy(url):
try:
with urllib.request.urlopen(url, timeout=2) as response:
return response.status == 200 and json.load(response).get("healthy") is True
except (OSError, ValueError):
return False
def wait_health(url, timeout=40):
end = time.monotonic() + timeout
while time.monotonic() < end:
if healthy(url):
return
time.sleep(0.25)
raise RuntimeError(f"Service did not become healthy: {url}; see pipelines logs")
def process_command(pid):
"""Return the OS command line for a live PID, or None when it cannot be read."""
try:
return subprocess.check_output(["ps", "-p", str(pid), "-o", "command="], text=True)
except (OSError, subprocess.CalledProcessError):
return None
def managed_pid(config):
path = Path(config["prefix"]) / "supervisor.pid"
try:
pid = int(path.read_text())
except (OSError, ValueError):
return None
if pid <= 1:
return None
command = process_command(pid)
# Never signal an arbitrary/reused PID.
if command is None or str(Path(config["prefix"]) / "lib/manage.py") not in command or "supervise" not in command:
return None
return pid
def registration(config):
return config.get("registration")
def service_command(config, arguments):
parser = argparse.ArgumentParser(prog="pipelines service",
description="Manage this native installation's server, authenticated web and ntfy login service.")
parser.add_argument("action", choices=("enable", "disable", "status"))
parser.add_argument("--print", dest="preview", action="store_true",
help="Preview enable's existing service definition without changing or starting anything")
if not arguments or arguments == ["help"]:
parser.print_help()
return
args = parser.parse_args(arguments)
if args.preview and args.action != "enable":
parser.error("--print is only supported with enable")
if ntfy_mode(config) != "native" or config.get("label") != "net.a-wan.pipelines" or not registration(config):
raise ValueError("No native installer login service is recorded; rerun ./install")
path = Path(registration(config))
if platform.system() == "Darwin":
expected = Path.home() / "Library/LaunchAgents/net.a-wan.pipelines.plist"
elif platform.system() == "Linux":
root = Path(config.get("opencode_env", {}).get("XDG_CONFIG_HOME") or Path.home() / ".config")
expected = root / "systemd/user/net.a-wan.pipelines.service"
else:
raise ValueError("Native login services require macOS launchd or Linux systemd --user")
if (path != expected or path.is_symlink() or not path.is_file()
or path.stat().st_uid != os.getuid()):
raise ValueError("Refusing an unexpected native service definition path or owner")
content = path.read_text()
if SERVICE_MARKER not in content:
raise ValueError("Refusing an unmanaged or standalone developer service definition")
if platform.system() == "Darwin":
definition = plistlib.loads(content.encode())
command = [config["python"], str(Path(config["prefix"]) / "lib/manage.py"),
"supervise", "--prefix", config["prefix"]]
if definition.get("Label") != config["label"] or definition.get("ProgramArguments") != command:
raise ValueError("Native service definition does not match this installation")
else:
def quote(value):
return '"' + value.replace('\\', '\\\\').replace('"', '\\"').replace('%', '%%').replace('$', '$$') + '"'
command = [config["python"], str(Path(config["prefix"]) / "lib/manage.py"),
"supervise", "--prefix", config["prefix"]]
if "ExecStart=" + " ".join(map(quote, command)) not in content.splitlines():
raise ValueError("Native service definition does not match this installation")
if args.preview:
print(content, end="")
elif args.action == "enable":
start(config)
print("Native login autostart enabled: server, authenticated web and ntfy.")
elif args.action == "disable":
if platform.system() == "Darwin":
run(["launchctl", "disable", f"gui/{os.getuid()}/{config['label']}"], quiet=True)
else:
run(["systemctl", "--user", "disable", config["label"] + ".service"], quiet=True)
stop(config)
print("Native login autostart disabled; supervisor stopped. Data and credentials retained.")
elif platform.system() == "Darwin":
domain = f"gui/{os.getuid()}"
disabled = run(["launchctl", "print-disabled", domain], quiet=True)
enabled = not re.search(r'"' + re.escape(config["label"]) + r'"\s*=>\s*true', disabled.stdout)
active = run(["launchctl", "print", domain + "/" + config["label"]], quiet=True, check=False).returncode == 0
print("Autostart:", "enabled" if enabled else "disabled")
print("Supervisor:", "loaded" if active else "not loaded")
else:
enabled = run(["systemctl", "--user", "is-enabled", config["label"] + ".service"], quiet=True, check=False)
active = run(["systemctl", "--user", "is-active", config["label"] + ".service"], quiet=True, check=False)
print("Autostart:", "enabled" if enabled.returncode == 0 else "disabled")
print("Supervisor:", "active" if active.returncode == 0 else "inactive")
def require_web_app(config):
"""The server never runs without its web app: both or neither."""
web = config.get("web") or {}
root = Path(web["root"]) if web.get("root") else None
if root is None or not (root / "index.html").is_file():
raise RuntimeError("The web app is not installed" + (f" in {root}" if root else "")
+ "; refusing to start the server without it. Run ./install.")
def start(config):
require_web_app(config)
root = Path(config["prefix"])
if registration(config):
if platform.system() == "Darwin":
target = f"gui/{os.getuid()}/{config['label']}"
run(["launchctl", "enable", target], quiet=True)
if run(["launchctl", "print", target], quiet=True, check=False).returncode:
run(["launchctl", "bootstrap", f"gui/{os.getuid()}", registration(config)], quiet=True)
run(["launchctl", "kickstart", target], quiet=True)
else:
run(["systemctl", "--user", "daemon-reload"], quiet=True)
run(["systemctl", "--user", "enable", "--now", config["label"] + ".service"], quiet=True)
elif managed_pid(config) is None:
log = (root / "logs/supervisor.log").open("a")
subprocess.Popen([config["python"], str(root / "lib/manage.py"), "supervise", "--prefix", str(root)],
stdin=subprocess.DEVNULL, stdout=log, stderr=log, start_new_session=True)
log.close()
wait_health(f"http://127.0.0.1:{config['server_port']}/healthz", timeout=75)
if config.get("web"):
web = config["web"]
host = "127.0.0.1" if web["host"] == "0.0.0.0" else web["host"]
end = time.monotonic() + 20
while True:
try:
with urllib.request.urlopen(f"http://{host}:{web['port']}/login", timeout=2) as response:
if response.status == 200:
break
except OSError:
pass
if time.monotonic() >= end:
raise RuntimeError("Web proxy did not become ready; see logs/web.log")
time.sleep(0.25)
def stop(config):
if registration(config):
if platform.system() == "Darwin":
run(["launchctl", "bootout", f"gui/{os.getuid()}", registration(config)], quiet=True, check=False)
else:
run(["systemctl", "--user", "stop", config["label"] + ".service"], quiet=True)
pid = managed_pid(config)
if pid is not None:
os.kill(pid, signal.SIGTERM)
deadline = time.monotonic() + 80
while managed_pid(config) is not None and time.monotonic() < deadline:
time.sleep(0.2)
if managed_pid(config) is not None:
raise RuntimeError("Supervisor did not stop; inspect logs before trying again")
if ntfy_mode(config) == "native":
ntfy_stop(config)
else:
compose(config, "stop", "ntfy", quiet=True)
def ntfy_start(config):
info = config["ntfy"]
log = (Path(config["prefix"]) / "logs/ntfy.log").open("a")
child = subprocess.Popen([info["bin"], "serve", "--config", info["config"]],
stdin=subprocess.DEVNULL, stdout=log, stderr=log, start_new_session=True)
log.close()
(Path(config["prefix"]) / "ntfy.pid").write_text(str(child.pid))
return child
def ntfy_stop(config):
path = Path(config["prefix"]) / "ntfy.pid"
try:
pid = int(path.read_text())
except (OSError, ValueError):
return
if pid <= 1:
return
command = process_command(pid)
# Never signal an arbitrary/reused PID: only the managed ntfy serve process.
# Accept the recorded path or its symlink-resolved form so a prefix reached
# through a symlinked HOME (macOS /var → /private/var) is still matched.
binary = str(config["ntfy"]["bin"])
candidates = {binary, str(Path(binary).resolve())}
if command is None or "serve" not in command or not any(candidate in command for candidate in candidates):
path.unlink(missing_ok=True)
return
os.kill(pid, signal.SIGTERM)
deadline = time.monotonic() + 10
while time.monotonic() < deadline:
try:
os.kill(pid, 0)
except ProcessLookupError:
break
time.sleep(0.1)
path.unlink(missing_ok=True)
def server_report(config):
"""The server's own startup report: the last `== Pipelines server` block
it wrote to its log."""
log = Path(config["prefix"]) / "logs/server.log"
try:
with log.open("rb") as handle:
handle.seek(max(0, log.stat().st_size - 64 * 1024))
lines = handle.read().decode("utf-8", "replace").splitlines()
except OSError:
return []
starts = [i for i, line in enumerate(lines) if line.startswith("== Pipelines server")]
if not starts:
return []
block = []
for line in lines[starts[-1]:]:
block.append(line)
if line == "==":
break
return block
def report(config):
"""Prints what is running: server, backends, web app and phone access."""
for line in server_report(config):
print(line)
web = config.get("web")
if web:
public = (config.get("opencode_env") or {}).get("PIPELINES_WEB_PUBLIC_URL")
print("== Access")
address = public or f"http://{web['host']}:{web['port']}"
print(f" {'Web':<10} {address} (password in {web['auth_file']})")
root = Path(web["root"]) if web.get("root") else None
built = root is not None and (root / "index.html").is_file()
print(f" {'Web app':<10} {'installed' if built else 'MISSING; the server will not start until ./install builds it'}")
updates = Path(web["updates"]) if web.get("updates") else None
apk = updates is not None and (updates / "pipelines.apk").is_file()
print(f" {'Phone app':<10} " + (f"{updates / 'pipelines.apk'} (Settings → Check for updates)"
if apk else "not built; run ./install --apk"))
print("==")
def active_runs(config):
"""Runs the server is still executing; an update waits for them."""
binary = str(Path(config["prefix"]) / "bin/pipelines")
result = run([binary, "--url", f"ws://127.0.0.1:{config['server_port']}/connect", "runs", "--json"],
quiet=True, check=False, timeout=60)
if result.returncode:
return None
try:
data = json.loads(result.stdout)
except ValueError:
return None
runs = data.get("runs", []) if isinstance(data, dict) else data
return [item for item in runs if isinstance(item, dict) and item.get("executing")]
def update(config):
"""Brings this installation to the newest source: pull, reinstall the same
way it was installed (data and credentials kept), restart, report."""
source = Path(config.get("source") or "")
if not (source / "install.sh").is_file():
raise ValueError("This installation does not record its source checkout; "
"run ./install from your Pipelines checkout to update it")
if healthy(f"http://127.0.0.1:{config['server_port']}/healthz"):
active = active_runs(config)
if active is None:
raise RuntimeError("Could not read the server's runs; update after checking `pipelines runs`")
if active:
raise RuntimeError(f"{len(active)} run(s) are still executing; update after they finish")
if (source / ".git").exists():
upstream = subprocess.run(["git", "-C", str(source), "rev-parse", "--abbrev-ref", "@{u}"],
capture_output=True, text=True)
if upstream.returncode:
print("The checkout tracks no upstream branch; installing it as it is.")
else:
pulled = subprocess.run(["git", "-C", str(source), "pull", "--ff-only"], text=True)
if pulled.returncode:
raise RuntimeError("git pull --ff-only failed; resolve the checkout, then rerun `pipelines update`")
installed = subprocess.run(["sh", str(source / "install.sh"), *config.get("install_args", [])])
if installed.returncode:
raise RuntimeError("The installer failed; the previous version keeps running")
config = load(config["prefix"])
stop(config)
start(config)
report(config)
def supervise(config):
root = Path(config["prefix"])
with (root / "supervisor.lock").open("a") as lock:
try:
fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB)
except BlockingIOError:
return
pidfile = root / "supervisor.pid"
pidfile.write_text(str(os.getpid()))
stopped = False
child = None
ntfy_child = None
web_child = None
def stopping(*_):
nonlocal stopped
stopped = True
for process in (child, ntfy_child, web_child):
if process is not None and process.poll() is None:
process.terminate()
signal.signal(signal.SIGTERM, stopping)
signal.signal(signal.SIGINT, stopping)
try:
require_web_app(config)
if ntfy_mode(config) == "native":
ntfy_child = ntfy_start(config)
else:
compose(config, "up", "-d", "ntfy", quiet=True)
wait_health(ntfy_health_url(config))
if stopped:
return
env = dict(os.environ)
env.update(config.get("opencode_env", {}))
env.update(HOME=str(Path.home()), PATH=config["path"], TZ=config["timezone"],
PIPELINES_NTFY_URL=f"http://127.0.0.1:{config['ntfy_port']}/{config['topic']}",
PIPELINES_NTFY_PUBLIC_URL=config["public_url"],
PIPELINES_NTFY_TOKEN_FILE=str(root / "secrets/publisher-token"))
env.pop("PIPELINES_NTFY_TOKEN", None)
# The server requires, and the proxy and every child CLI send, the
# shared token in this file (installs from before it have none).
env.update(server_token_env(config))
server_command = [str(root / "bin/pipelines-server"), "-addr",
server_address(config), "-db", str(root / "data/pipelines.db")]
if config.get("allow_authoring") is True:
server_command.append("-allow-authoring")
server_command += mdns_args(config)
with (root / "logs/server.log").open("a") as log:
child = subprocess.Popen(server_command, cwd=config["workspace"], env=env, stdout=log, stderr=log)
if config.get("web"):
web = config["web"]
web_env = dict(env)
web_env.pop("PIPELINES_WEB_AUTH", None)
web_env["PIPELINES_WEB_AUTH_FILE"] = web["auth_file"]
with (root / "logs/web.log").open("a") as web_log:
web_child = subprocess.Popen(
[web["node"], web["script"], "--port", str(web["port"]),
"--host", web["host"], "--pipelines", f"127.0.0.1:{config['server_port']}",
*(["--root", web["root"]] if web.get("root") else []),
*(["--updates", web["updates"]] if web.get("updates") else [])],
env=web_env, stdout=web_log, stderr=web_log)
while child.poll() is None and not stopped:
if web_child is not None and web_child.poll() is not None:
raise RuntimeError("Authenticated web proxy exited; see logs/web.log")
time.sleep(0.25)
if not stopped and child.returncode:
raise RuntimeError("Pipeline server exited; see logs/server.log")
finally:
if web_child is not None and web_child.poll() is None:
web_child.terminate()
try:
web_child.wait(timeout=10)
except subprocess.TimeoutExpired:
web_child.kill()
web_child.wait()
if child is not None and child.poll() is None:
child.terminate()
try:
child.wait(timeout=70)
except subprocess.TimeoutExpired:
child.kill()
child.wait()
if ntfy_mode(config) == "native":
if ntfy_child is not None and ntfy_child.poll() is None:
ntfy_child.terminate()
try:
ntfy_child.wait(timeout=10)
except subprocess.TimeoutExpired:
ntfy_child.kill()
ntfy_child.wait()
(root / "ntfy.pid").unlink(missing_ok=True)
else:
compose(config, "stop", "ntfy", quiet=True, check=False)
pidfile.unlink(missing_ok=True)
def uninstall(config, purge=False, yes=False):
root = Path(config["prefix"])
if not yes and input("Uninstall Pipelines? [y/N] ").strip().lower() != "y":
return
if purge and not yes and input("Also DELETE pipeline history, credentials, and this install's ntfy volume? Type DELETE: ") != "DELETE":
raise ValueError("Purge canceled; nothing deleted")
stop(config)
if registration(config):
if platform.system() != "Darwin":
run(["systemctl", "--user", "disable", config["label"] + ".service"], quiet=True, check=False)
Path(registration(config)).unlink(missing_ok=True)
if ntfy_mode(config) != "native":
compose(config, "down", *(["--volumes"] if purge else []), quiet=True)
link = Path(config["launcher"])
if link.is_symlink() and link.resolve() == (root / "bin/pipelines").resolve():
if str(link)=="/usr/local/bin/pipelines" and not os.access(link.parent,os.W_OK):
subprocess.run(["sudo","rm",str(link)],check=True)
else:
link.unlink()
if purge:
# Only the explicitly identified, owned installation directory is removed.
shutil.rmtree(root)
print("Removed installation and its pipeline/ntfy data. Host OpenCode was untouched.")
else:
for path in (root / "bin", root / "lib"):
if path.exists():
shutil.rmtree(path)
config["registration"] = None
config["uninstalled"] = True
(root / MARKER).write_text(json.dumps(config, indent=2))
print(f"Uninstalled. Data and ntfy volume retained at {root}; reinstall to reuse them.")
def main():
lifecycle = ("start", "stop", "restart", "status", "doctor", "logs", "supervise", "uninstall", "update")
# Strip only the launcher's installation selector. All application arguments
# belong to the shared Go CLI (including global flags before the command).
selector = argparse.ArgumentParser(add_help=False)
selector.add_argument("--prefix", type=Path, default=DEFAULT_PREFIX)
selected, forwarded = selector.parse_known_args()
config = load(selected.prefix)
if forwarded and forwarded[0] in ("service", "native-service"):
service_command(config, forwarded[1:])
return
if not forwarded or forwarded[0] not in lifecycle:
binary = str(Path(config["prefix"]) / "bin/pipelines")
env = dict(os.environ)
env.update(config.get("opencode_env", {}))
env.update(PIPELINES_URL=f"ws://127.0.0.1:{config['server_port']}/connect",
PIPELINES_OPENCODE=config["opencode"], PATH=config["path"])
env.update(server_token_env(config))
os.execve(binary, [binary, *(forwarded or ["tui"])], env)
return
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("action", nargs="?", default="tui")
parser.add_argument("--prefix", type=Path, default=DEFAULT_PREFIX)
parser.add_argument("--purge", action="store_true")
parser.add_argument("--yes", action="store_true")
args, rest = parser.parse_known_args()
if args.action in lifecycle and rest:
parser.error("unexpected arguments: " + " ".join(rest))
if args.action == "start":
start(config)
report(config)
elif args.action == "stop":
stop(config)
elif args.action == "restart":
stop(config); start(config)
report(config)
elif args.action in ("status", "doctor"):
report(config)
print("Pipeline server:", "healthy" if healthy(f"http://127.0.0.1:{config['server_port']}/healthz") else "stopped/unhealthy")
print("ntfy:", "healthy" if healthy(ntfy_health_url(config)) else "stopped/unhealthy")
print("Phone server:", config["public_url"], "· topic:", config["topic"], "· username:", config["username"])
if args.action == "doctor":
run([config["opencode"], "api", "get", "/api/info"], quiet=True)
print("Host OpenCode API: responding (model execution is a separate check)")
elif args.action == "logs":
os.execvp("tail", ["tail", "-n", "100", "-f", str(Path(config["prefix"]) / "logs/server.log")])
elif args.action == "update":
update(config)
elif args.action == "supervise":
supervise(config)
elif args.action == "uninstall":
uninstall(config, args.purge, args.yes)
if __name__ == "__main__":
try:
main()
except (ValueError, RuntimeError, OSError, subprocess.SubprocessError) as error:
sys.exit(str(error))