8adc6b8080
The native install hardcoded -addr 127.0.0.1, so the server was unreachable from
the phone: the emulator worked because it proxies to the host loopback, but a
real device could not connect even though ntfy (bound to 0.0.0.0:8090) worked.
The bind address is now a manifest setting (server_address() in manage.py, with
older manifests still defaulting to loopback) and setup-native.py records it,
defaulting to 0.0.0.0 like the Docker install did and offering
--bind-address 127.0.0.1 for a loopback-only server. An invalid address is
rejected, and setup prints the phone client URL.
Verified: scripts test suite 116 tests OK, and after reinstalling the server
listens on *:8080 and answers {"healthy":true} on 127.0.0.1, 10.0.0.75,
10.0.0.249 and the tailnet address.
335 lines
14 KiB
Python
335 lines
14 KiB
Python
#!/usr/bin/env python3
|
|
"""One per-user lifecycle for the native server and its private Docker ntfy."""
|
|
import argparse
|
|
import fcntl
|
|
import json
|
|
import os
|
|
from pathlib import Path
|
|
import platform
|
|
import shutil
|
|
import signal
|
|
import subprocess
|
|
import sys
|
|
import time
|
|
import urllib.request
|
|
|
|
DEFAULT_PREFIX = Path.home() / ".local/share/pipelines"
|
|
MARKER = "pipelines-install.json"
|
|
|
|
|
|
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 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 start(config):
|
|
root = Path(config["prefix"])
|
|
if registration(config):
|
|
if platform.system() == "Darwin":
|
|
target = f"gui/{os.getuid()}/{config['label']}"
|
|
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)
|
|
|
|
|
|
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 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
|
|
|
|
def stopping(*_):
|
|
nonlocal stopped
|
|
stopped = True
|
|
for process in (child, ntfy_child):
|
|
if process is not None and process.poll() is None:
|
|
process.terminate()
|
|
|
|
signal.signal(signal.SIGTERM, stopping)
|
|
signal.signal(signal.SIGINT, stopping)
|
|
try:
|
|
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)
|
|
with (root / "logs/server.log").open("a") as log:
|
|
child = subprocess.Popen([str(root / "bin/pipelines-server"), "-addr",
|
|
server_address(config), "-db", str(root / "data/pipelines.db")],
|
|
cwd=config["workspace"], env=env, stdout=log, stderr=log)
|
|
while child.poll() is None and not stopped:
|
|
time.sleep(0.25)
|
|
if not stopped and child.returncode:
|
|
raise RuntimeError("Pipeline server exited; see logs/server.log")
|
|
finally:
|
|
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")
|
|
# 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 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"])
|
|
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)
|
|
elif args.action == "stop":
|
|
stop(config)
|
|
elif args.action == "restart":
|
|
stop(config); start(config)
|
|
elif args.action in ("status", "doctor"):
|
|
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 == "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))
|