From 8016108558b8c50d5246404a5ceb0b23e37605b5 Mon Sep 17 00:00:00 2001 From: Alan Silva Date: Sun, 8 Nov 2026 21:47:03 +0000 Subject: [PATCH 1/6] Reload web password safely without restarting active sessions --- web/serve.mjs | 19 +++++++++++++----- web/test/authReload.test.mjs | 37 ++++++++++++++++++++++++++++++++++++ 2 files changed, 51 insertions(+), 5 deletions(-) create mode 100644 web/test/authReload.test.mjs diff --git a/web/serve.mjs b/web/serve.mjs index 3faa8aca..fe7354a8 100644 --- a/web/serve.mjs +++ b/web/serve.mjs @@ -47,7 +47,7 @@ const AUTH_FILE = process.env.PIPELINES_WEB_AUTH_FILE ?? join(homedir(), ".config", "pipelines", "web-auth.json"); const SESSION_COOKIE = "pipelines_session"; -function loadAuth() { +function loadAuth(fatal = true) { if (AUTH_DISABLED) return null; try { const parsed = JSON.parse(readFileSync(AUTH_FILE, "utf8")); @@ -62,12 +62,13 @@ function loadAuth() { } catch { // Fall through to the refusal below. } - console.error( - `web auth: refusing to start without ${AUTH_FILE} (or PIPELINES_WEB_AUTH=disabled for tests)`, - ); + if (!fatal) throw new Error("Web authentication is temporarily unavailable"); + console.error(`web auth: refusing to start without ${AUTH_FILE} (or PIPELINES_WEB_AUTH=disabled for tests)`); process.exit(1); } -const auth = loadAuth(); +let auth = loadAuth(); + +function refreshAuth() { auth = loadAuth(false); } function cookieValue(req, name) { for (const part of String(req.headers.cookie ?? "").split(";")) { @@ -387,6 +388,10 @@ function proxyArtifact(req, res) { } const server = createServer(async (req, res) => { + try { refreshAuth(); } catch { + res.writeHead(503, { "Content-Type": "text/plain", "Cache-Control": "no-store" }).end("Web authentication unavailable"); + return; + } const pathname = (req.url ?? "/").split("?")[0]; // Icons and the web manifest are public: the sign-in page shows the icon, // and browsers and app installers fetch them without the session cookie. @@ -543,6 +548,10 @@ function proxyUpgrade(req, clientSocket, clientHead) { } server.on("upgrade", (req, clientSocket, clientHead) => { + try { refreshAuth(); } catch { + clientSocket.end("HTTP/1.1 503 Service Unavailable\r\nContent-Length: 0\r\n\r\n"); + return; + } const pathname = (req.url ?? "").split("?")[0]; if (!sameOriginUpgrade(req.headers.origin, req.headers.host)) { clientSocket.write("HTTP/1.1 403 Forbidden\r\nConnection: close\r\nContent-Length: 0\r\n\r\n"); diff --git a/web/test/authReload.test.mjs b/web/test/authReload.test.mjs new file mode 100644 index 00000000..a597f2a6 --- /dev/null +++ b/web/test/authReload.test.mjs @@ -0,0 +1,37 @@ +import test from "node:test"; +import assert from "node:assert/strict"; +import { spawn } from "node:child_process"; +import { mkdtemp, writeFile, rename, rm } from "node:fs/promises"; +import { tmpdir } from "node:os"; +import { join } from "node:path"; +import { fileURLToPath } from "node:url"; +import { createServer } from "node:net"; +import { once } from "node:events"; + +test("atomic password updates take effect without restart and fail closed on invalid files", async (t) => { + const dir = await mkdtemp(join(tmpdir(), "pipelines-auth-reload-")); + t.after(() => rm(dir, { recursive: true, force: true })); + const auth = join(dir, "auth.json"); + const data = { password: "old-password", secret: "s".repeat(40) }; + await writeFile(auth, JSON.stringify(data)); + const portServer = createServer().listen(0,"127.0.0.1"); await once(portServer,"listening"); + const port = portServer.address().port; await new Promise((done) => portServer.close(done)); + const child = spawn(process.execPath, ["serve.mjs", "--port", String(port)], { + cwd: fileURLToPath(new URL("..", import.meta.url)), + env: { ...process.env, PIPELINES_WEB_AUTH: "", PIPELINES_WEB_AUTH_FILE: auth }, stdio:["ignore","pipe","inherit"] }); + t.after(async () => { const stopped = once(child,"exit"); child.kill(); await stopped; }); + await once(child.stdout,"data"); + const base = `http://127.0.0.1:${port}`; + const login = (password) => fetch(base + "/login", { method:"POST", body:new URLSearchParams({password}), redirect:"manual" }); + const first = await login("old-password"); assert.equal(first.status,303); + const cookie = first.headers.get("set-cookie").split(";")[0]; + await writeFile(auth + ".next", JSON.stringify({ ...data, password:"new-password" })); await rename(auth + ".next",auth); + assert.equal((await login("old-password")).status,401); + assert.equal((await login("new-password")).status,303); + assert.equal((await fetch(base + "/login", {headers:{Cookie:cookie},redirect:"manual"})).status,302); + await writeFile(auth + ".next", "malformed"); await rename(auth + ".next",auth); + assert.equal((await login("new-password")).status,503); + assert.equal((await fetch(base + "/login", {headers:{Cookie:cookie},redirect:"manual"})).status,503); + await writeFile(auth,JSON.stringify(data)); + assert.equal((await login("old-password")).status,303); +}); From 543e3f063a12ed0adf8e8d598b16bce3e8e241e8 Mon Sep 17 00:00:00 2001 From: Alan Silva Date: Sun, 8 Nov 2026 21:45:51 +0000 Subject: [PATCH 2/6] Add interactive password change command without service restart --- docs/install.md | 16 ++++- docs/notes/password-command.md | 24 +++++++ password | 3 + scripts/password.py | 101 +++++++++++++++++++++++++++ scripts/test_password.py | 124 +++++++++++++++++++++++++++++++++ 5 files changed, 266 insertions(+), 2 deletions(-) create mode 100644 docs/notes/password-command.md create mode 100755 password create mode 100644 scripts/password.py create mode 100644 scripts/test_password.py diff --git a/docs/install.md b/docs/install.md index 6bbe8a16..fbd8bfda 100644 --- a/docs/install.md +++ b/docs/install.md @@ -319,8 +319,20 @@ the installer rather than being reset. The same password is given to the ntfy `phone-reader` account when that account is first created; existing ntfy accounts keep their passwords. -To change the web password, edit `password` in `web-auth.json` (keep it 0600) -and run `pipelines restart`. +After updating the installation, change the web sign-in password from the +checkout with: + +```sh +./password +``` + +It prompts twice without echoing the password, requires at least eight +characters, and writes the private password file atomically. The updated web +proxy picks it up on the next request; no service restart is needed, and existing +sessions and running tasks remain connected. SSH is supported with an interactive +TTY. This changes the web/app sign-in password; the ntfy notification account's +password is unchanged. `--prefix PATH` selects another installation, and +`PIPELINES_WEB_AUTH_FILE` selects an explicitly configured password file. ## Upgrading diff --git a/docs/notes/password-command.md b/docs/notes/password-command.md new file mode 100644 index 00000000..d2c162d5 --- /dev/null +++ b/docs/notes/password-command.md @@ -0,0 +1,24 @@ +# Password command + +Added checkout entry point `./password` with twice-entered hidden input and an +8-character minimum. It uses the existing installation's recorded password file, +explicit PIPELINES_WEB_AUTH_FILE, or default private file for partial installs. +Password arguments are not accepted, and non-TTY use is refused before prompting. + +The helper validates file ownership, regular-file type, permissions and auth JSON; +stages on the destination filesystem, fsyncs content and atomically replaces the +file. Concurrent helper updates serialize on the parent directory lock, and an +external change detected during staging is not overwritten. Cookie secret and +unknown metadata remain unchanged, preserving existing sessions. No service, +background task, provider credential or ntfy account is modified. + +Runtime use requires the updated proxy's per-request auth reload, implemented in +the browser-discovery/relay lane. Merely updating a checkout does not replace an +already-running installed proxy. The helper does not kill a proxy: the existing +supervisor would treat that as a fatal service exit. + +Verification: 11 focused tests passed, covering custom/default/partial-install +paths, private ownership boundaries, old-file preservation on errors, same-device +atomic replacement, external-write refusal, prompt retry/privacy and non-TTY +refusal. Wrapper help, shell syntax, Python compilation and diff checks passed. +No operator password or running service was changed during testing. diff --git a/password b/password new file mode 100755 index 00000000..699e68e8 --- /dev/null +++ b/password @@ -0,0 +1,3 @@ +#!/bin/sh +set -eu +exec python3 "$(dirname "$0")/scripts/password.py" "$@" diff --git a/scripts/password.py b/scripts/password.py new file mode 100644 index 00000000..9c2b854a --- /dev/null +++ b/scripts/password.py @@ -0,0 +1,101 @@ +#!/usr/bin/env python3 +"""Change the local Pipelines web sign-in password without restarting services.""" +import argparse +import fcntl +import getpass +import json +import os +from pathlib import Path +import stat +import sys +import tempfile + + +def auth_path(*, prefix=None, home=None, environ=None): + home = Path(home or Path.home()) + env = os.environ if environ is None else environ + selected = Path(prefix or env.get("PIPELINES_PREFIX") or home / ".local/share/pipelines").expanduser().resolve() + explicit = env.get("PIPELINES_WEB_AUTH_FILE") + if explicit: + return Path(explicit).expanduser().absolute() + manifest = selected / "pipelines-install.json" + if manifest.exists(): + if manifest.is_symlink() or manifest.stat().st_uid != os.getuid(): + raise ValueError("Refusing an unsafe installation manifest") + data = json.loads(manifest.read_text()) + if data.get("format") != 1 or data.get("prefix") != str(selected): + raise ValueError("Invalid Pipelines installation manifest") + recorded = (data.get("web") or {}).get("auth_file") + if recorded: + return Path(recorded).expanduser().absolute() + return home / ".config/pipelines/web-auth.json" + + +def read_auth(path): + path = Path(path) + info = path.lstat() + if not stat.S_ISREG(info.st_mode) or info.st_uid != os.getuid(): + raise ValueError("Password file must be a regular file owned by this user") + if info.st_mode & 0o077: + raise ValueError(f"Password file must be private: chmod 600 '{path}'") + data = json.loads(path.read_text()) + if not isinstance(data, dict) or not isinstance(data.get("password"), str) or len(data["password"]) < 8 or not isinstance(data.get("secret"), str) or len(data["secret"]) < 32: + raise ValueError("Invalid Pipelines password file; it was retained unchanged") + return data, info + + +def change_password(path, password): + if len(password) < 8: + raise ValueError("Choose a password of at least 8 characters") + path = Path(path) + # Lock the directory inode, which remains stable across atomic file replaces. + directory = os.open(path.parent, os.O_RDONLY) + try: + fcntl.flock(directory, fcntl.LOCK_EX) + data, original = read_auth(path) + data["password"] = password + descriptor, temporary = tempfile.mkstemp(prefix=".pipelines-password-", dir=path.parent) + try: + with os.fdopen(descriptor, "w") as output: + os.fchmod(output.fileno(), 0o600) + json.dump(data, output, indent=2) + output.write("\n") + output.flush() + os.fsync(output.fileno()) + current = path.lstat() + if (current.st_dev, current.st_ino, current.st_mtime_ns, current.st_size) != (original.st_dev, original.st_ino, original.st_mtime_ns, original.st_size): + raise ValueError("Password file changed during the update; retry the command") + os.replace(temporary, path) + finally: + Path(temporary).unlink(missing_ok=True) + finally: + os.close(directory) + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--prefix", type=Path, help="Installation prefix (or PIPELINES_PREFIX)") + args = parser.parse_args() + path = auth_path(prefix=args.prefix) + read_auth(path) + if not sys.stdin.isatty(): + raise ValueError("Run ./password in an interactive terminal (SSH with a TTY is supported)") + while True: + password = getpass.getpass("New Pipelines password: ") + confirmation = getpass.getpass("Confirm new password: ") + if len(password) < 8: + print("Choose a password of at least 8 characters.", file=sys.stderr) + elif password != confirmation: + print("Passwords do not match. Try again.", file=sys.stderr) + else: + break + change_password(path, password) + print("Web sign-in password changed. No service restart is needed.") + print("Existing sessions remain signed in. The notification password is unchanged.") + + +if __name__ == "__main__": + try: + main() + except (OSError, ValueError, KeyboardInterrupt) as error: + sys.exit(f"Password not changed: {error}") diff --git a/scripts/test_password.py b/scripts/test_password.py new file mode 100644 index 00000000..5383109b --- /dev/null +++ b/scripts/test_password.py @@ -0,0 +1,124 @@ +import importlib.util +import json +import io +import os +from pathlib import Path +import tempfile +import unittest +from unittest.mock import patch + +spec = importlib.util.spec_from_file_location("pipelines_password", Path(__file__).with_name("password.py")) +password = importlib.util.module_from_spec(spec) +spec.loader.exec_module(password) + + +class PasswordTests(unittest.TestCase): + def setUp(self): + self.temporary = tempfile.TemporaryDirectory(prefix="pipelines-password-test-") + self.addCleanup(self.temporary.cleanup) + self.home = Path(self.temporary.name).resolve() + self.auth = self.home / ".config/pipelines/web-auth.json" + self.auth.parent.mkdir(parents=True) + self.original = {"password": "old password", "secret": "s" * 32, "other": "preserve"} + self.auth.write_text(json.dumps(self.original)) + self.auth.chmod(0o600) + + def test_default_path_works_for_partial_install_without_manifest(self): + self.assertEqual(password.auth_path(home=self.home, environ={}), self.auth) + + def test_manifest_custom_auth_and_explicit_environment(self): + prefix = self.home / "installation" + prefix.mkdir() + recorded = self.home / "custom-auth.json" + (prefix / "pipelines-install.json").write_text(json.dumps({ + "format": 1, "prefix": str(prefix), "web": {"auth_file": str(recorded)}})) + self.assertEqual(password.auth_path(home=self.home, prefix=prefix, environ={}), recorded) + self.assertEqual(password.auth_path(home=self.home, prefix=prefix, + environ={"PIPELINES_WEB_AUTH_FILE": str(self.auth)}), self.auth) + + def test_change_preserves_cookie_secret_metadata_and_private_permissions(self): + password.change_password(self.auth, "new password") + result = json.loads(self.auth.read_text()) + self.assertEqual(result, dict(self.original, password="new password")) + self.assertEqual(self.auth.stat().st_mode & 0o777, 0o600) + self.assertEqual(list(self.auth.parent.glob(".pipelines-password-*")), []) + + def test_short_password_does_not_modify_auth(self): + with self.assertRaises(ValueError): + password.change_password(self.auth, "short") + self.assertEqual(json.loads(self.auth.read_text()), self.original) + + def test_symlinked_password_is_refused_and_target_untouched(self): + link = self.home / "link.json" + link.symlink_to(self.auth) + with self.assertRaises(ValueError): + password.change_password(link, "new password") + self.assertEqual(json.loads(self.auth.read_text()), self.original) + self.assertTrue(link.is_symlink()) + + def test_public_or_malformed_auth_is_not_replaced(self): + self.auth.chmod(0o644) + with self.assertRaisesRegex(ValueError, "private"): + password.change_password(self.auth, "new password") + self.auth.chmod(0o600) + self.auth.write_text("{broken") + with self.assertRaises(ValueError): + password.change_password(self.auth, "new password") + self.assertEqual(self.auth.read_text(), "{broken") + + def test_replacement_failure_preserves_original_and_cleans_staging(self): + before = self.auth.read_bytes() + with patch.object(password.os, "replace", side_effect=OSError("fixture failure")): + with self.assertRaises(OSError): + password.change_password(self.auth, "new password") + self.assertEqual(self.auth.read_bytes(), before) + self.assertEqual(list(self.auth.parent.glob(".pipelines-password-*")), []) + + def test_atomic_replace_occurs_on_destination_filesystem(self): + replace = os.replace + calls = [] + def checked_replace(source, target): + calls.append((source, target)) + self.assertEqual(Path(source).parent, self.auth.parent) + return replace(source, target) + with patch.object(password.os, "replace", side_effect=checked_replace): + password.change_password(self.auth, "new password") + self.assertEqual(len(calls), 1) + + def test_file_changed_during_update_is_not_overwritten(self): + replace = os.fsync + def external_update(descriptor): + self.auth.write_text(json.dumps(dict(self.original, password="changed elsewhere"))) + return replace(descriptor) + with patch.object(password.os, "fsync", side_effect=external_update): + with self.assertRaisesRegex(ValueError, "changed during"): + password.change_password(self.auth, "new password") + self.assertEqual(json.loads(self.auth.read_text())["password"], "changed elsewhere") + self.assertEqual(list(self.auth.parent.glob(".pipelines-password-*")), []) + + def test_cli_retries_mismatch_and_does_not_print_password(self): + output = io.StringIO() + errors = io.StringIO() + with patch.object(password.sys, "argv", ["password"]), \ + patch.object(password, "auth_path", return_value=self.auth), \ + patch.object(password.sys.stdin, "isatty", return_value=True), \ + patch.object(password.getpass, "getpass", side_effect=[ + "first password", "wrong confirmation", "new password", "new password"]), \ + patch.object(password.sys, "stdout", output), \ + patch.object(password.sys, "stderr", errors): + password.main() + self.assertEqual(json.loads(self.auth.read_text())["password"], "new password") + self.assertIn("do not match", errors.getvalue()) + self.assertIn("No service restart", output.getvalue()) + for value in ("first password", "wrong confirmation", "new password", "old password"): + self.assertNotIn(value, output.getvalue() + errors.getvalue()) + + def test_cli_refuses_non_tty_before_prompting(self): + with patch.object(password.sys, "argv", ["password"]), \ + patch.object(password, "auth_path", return_value=self.auth), \ + patch.object(password.sys.stdin, "isatty", return_value=False), \ + patch.object(password.getpass, "getpass") as prompt: + with self.assertRaisesRegex(ValueError, "interactive terminal"): + password.main() + prompt.assert_not_called() + self.assertEqual(json.loads(self.auth.read_text()), self.original) From b69d7efb4a6ec4d1068265e5fbf42c7b647f7a8e Mon Sep 17 00:00:00 2001 From: Alan Silva Date: Sun, 8 Nov 2026 21:50:27 +0000 Subject: [PATCH 3/6] Find LAN servers from browser and review discovered machine names --- .../browser_discovery_fetch_stub.dart | 3 + .../browser_discovery_fetch_web.dart | 30 +++++ .../discovery/browser_server_discovery.dart | 59 +++++++++ .../onboarding/discovery/discovery_panel.dart | 9 ++ .../discovery/server_discovery.dart | 7 +- .../features/onboarding/onboarding_flow.dart | 32 ++++- .../settings/saved_server_editor.dart | 29 +++- app/notes/browser-network-discovery.md | 16 +++ .../browser_server_discovery_test.dart | 60 +++++++++ .../discovery/discovered_server_test.dart | 4 +- .../discovery/discovery_panel_test.dart | 10 +- .../settings/saved_server_discovery_test.dart | 124 ++++++++++++++++++ 12 files changed, 371 insertions(+), 12 deletions(-) create mode 100644 app/lib/features/onboarding/discovery/browser_discovery_fetch_stub.dart create mode 100644 app/lib/features/onboarding/discovery/browser_discovery_fetch_web.dart create mode 100644 app/lib/features/onboarding/discovery/browser_server_discovery.dart create mode 100644 app/notes/browser-network-discovery.md create mode 100644 app/test/features/onboarding/discovery/browser_server_discovery_test.dart create mode 100644 app/test/features/settings/saved_server_discovery_test.dart diff --git a/app/lib/features/onboarding/discovery/browser_discovery_fetch_stub.dart b/app/lib/features/onboarding/discovery/browser_discovery_fetch_stub.dart new file mode 100644 index 00000000..9b4d5458 --- /dev/null +++ b/app/lib/features/onboarding/discovery/browser_discovery_fetch_stub.dart @@ -0,0 +1,3 @@ +Future fetchDiscovery() => Future.error( + UnsupportedError('Browser discovery requires the web client.'), +); diff --git a/app/lib/features/onboarding/discovery/browser_discovery_fetch_web.dart b/app/lib/features/onboarding/discovery/browser_discovery_fetch_web.dart new file mode 100644 index 00000000..79b74617 --- /dev/null +++ b/app/lib/features/onboarding/discovery/browser_discovery_fetch_web.dart @@ -0,0 +1,30 @@ +import 'dart:js_interop'; + +@JS('fetch') +external JSPromise<_Response> _fetch(JSString url, _Options options); + +extension type _Options._(JSObject _) implements JSObject { + external factory _Options({JSString credentials, JSString cache}); +} + +extension type _Response._(JSObject _) implements JSObject { + external int get status; + external JSPromise text(); +} + +Future fetchDiscovery() async { + final response = await _fetch( + '/api/discovery'.toJS, + _Options(credentials: 'same-origin'.toJS, cache: 'no-store'.toJS), + ).toDart; + if (response.status == 401 || response.status == 403) { + throw StateError('Sign in to this server before searching the network.'); + } + if (response.status == 404) { + throw StateError('Update this server to enable browser network discovery.'); + } + if (response.status != 200) { + throw StateError('Network discovery failed (HTTP ${response.status}).'); + } + return (await response.text().toDart).toDart; +} diff --git a/app/lib/features/onboarding/discovery/browser_server_discovery.dart b/app/lib/features/onboarding/discovery/browser_server_discovery.dart new file mode 100644 index 00000000..48bf6ab4 --- /dev/null +++ b/app/lib/features/onboarding/discovery/browser_server_discovery.dart @@ -0,0 +1,59 @@ +import 'dart:convert'; +import '../../../core/transport/server_url.dart'; +import 'discovered_server.dart'; +import 'server_discovery.dart'; +import 'browser_discovery_fetch_stub.dart' + if (dart.library.js_interop) 'browser_discovery_fetch_web.dart' + as impl; + +/// The authenticated web front door browses its LAN on the browser's behalf. +class BrowserServerDiscovery implements ServerDiscovery { + BrowserServerDiscovery({Future Function()? fetch}) + : _fetch = fetch ?? impl.fetchDiscovery; + final Future Function() _fetch; + + @override + Stream> scan() async* { + final body = await _fetch().timeout(const Duration(seconds: 8)); + if (body.length > 262144) { + throw const FormatException('Discovery response is too large.'); + } + final envelope = jsonDecode(body); + if (envelope is! Map || envelope['discovered_servers'] is! List) { + throw const FormatException( + 'This server did not return network discovery results.', + ); + } + final servers = {}; + for (final item in (envelope['discovered_servers'] as List).take(256)) { + if (item is! Map || + item['endpoint'] is! String || + item['name'] is! String) { + continue; + } + try { + final validated = ServerUrl.validate(item['endpoint'] as String); + final uri = Uri.parse(validated.wsUrl); + final name = (item['name'] as String).trim(); + if (name.isEmpty || + name.length > 256 || + uri.hasQuery || + uri.hasFragment) { + continue; + } + servers[uri] = DiscoveredServer( + name: name, + host: uri.host, + port: validated.port, + secure: uri.scheme == 'wss', + path: uri.path, + passwordRequired: item['auth'] != 'none', + version: item['version'] is String ? item['version'] as String : null, + ); + } on FormatException { + // One malformed announcement must not hide other machines. + } + } + yield servers.values.toList(); + } +} diff --git a/app/lib/features/onboarding/discovery/discovery_panel.dart b/app/lib/features/onboarding/discovery/discovery_panel.dart index 8010a3e7..67597227 100644 --- a/app/lib/features/onboarding/discovery/discovery_panel.dart +++ b/app/lib/features/onboarding/discovery/discovery_panel.dart @@ -5,6 +5,7 @@ import 'package:flutter/material.dart'; import '../../../ui/adaptive/host.dart'; import 'discovered_server.dart'; +import 'browser_server_discovery.dart'; import 'server_discovery.dart'; enum _Phase { idle, scanning, done, failed } @@ -62,6 +63,12 @@ class _DiscoveryPanelState extends State { (servers) { if (mounted) setState(() => _servers = servers); }, + onDone: () { + _timer?.cancel(); + if (mounted && _phase == _Phase.scanning) { + setState(() => _phase = _Phase.done); + } + }, onError: (Object error) { _stop(); if (mounted) { @@ -126,6 +133,8 @@ class _DiscoveryPanelState extends State { crossAxisAlignment: CrossAxisAlignment.stretch, children: [ button, + if (widget.discovery is BrowserServerDiscovery) + const Text('Searches this server’s local network.'), ?status, for (final server in _servers) _row(context, cupertino, server), ], diff --git a/app/lib/features/onboarding/discovery/server_discovery.dart b/app/lib/features/onboarding/discovery/server_discovery.dart index 3e8d41ac..033a1e7c 100644 --- a/app/lib/features/onboarding/discovery/server_discovery.dart +++ b/app/lib/features/onboarding/discovery/server_discovery.dart @@ -1,6 +1,7 @@ import 'package:flutter/foundation.dart'; import 'bonsoir_server_discovery.dart'; +import 'browser_server_discovery.dart'; import 'discovered_server.dart'; /// Finds Pipelines servers on the local network. @@ -12,7 +13,7 @@ abstract interface class ServerDiscovery { /// The discovery this platform supports, or null where there is none. /// -/// Browsers cannot send mDNS, and the web app is served by the server it -/// talks to, so web has no scan. +/// Browsers ask their authenticated front door to browse its LAN. Native +/// clients browse directly through the platform DNS-SD service. ServerDiscovery? platformServerDiscovery({bool web = kIsWeb}) => - web ? null : BonsoirServerDiscovery(); + web ? BrowserServerDiscovery() : BonsoirServerDiscovery(); diff --git a/app/lib/features/onboarding/onboarding_flow.dart b/app/lib/features/onboarding/onboarding_flow.dart index d0954f52..228084d4 100644 --- a/app/lib/features/onboarding/onboarding_flow.dart +++ b/app/lib/features/onboarding/onboarding_flow.dart @@ -26,6 +26,7 @@ class OnboardingFlow extends StatefulWidget { this.check = ServerSession.check, this.signIn = ServerSession.signIn, this.saveServer, + this.saveServerProfile, this.savedServers, this.serverAddresses = const [], this.discovery, @@ -42,10 +43,11 @@ class OnboardingFlow extends StatefulWidget { final ServerCheck check; final ServerSignIn signIn; final Future Function(String url)? saveServer; + final Future Function(String url, String name)? saveServerProfile; final Widget? savedServers; final List serverAddresses; - /// LAN discovery; null hides the scan (web, or no platform support). + /// Network discovery; null hides the scan when no service was supplied. final ServerDiscovery? discovery; @override @@ -57,6 +59,7 @@ class _OnboardingFlowState extends State { text: widget.initialServer, ); final TextEditingController _password = TextEditingController(); + final TextEditingController _name = TextEditingController(); late bool _passwordStep = widget.startAtPassword; Uri? _endpoint; bool _busy = false; @@ -72,6 +75,7 @@ class _OnboardingFlowState extends State { void dispose() { _server.dispose(); _password.dispose(); + _name.dispose(); super.dispose(); } @@ -120,7 +124,14 @@ class _OnboardingFlowState extends State { return; } try { - await widget.saveServer?.call(endpoint.toString()); + if (widget.saveServerProfile != null) { + await widget.saveServerProfile!( + endpoint.toString(), + _name.text.trim().isEmpty ? endpoint.host : _name.text.trim(), + ); + } else { + await widget.saveServer?.call(endpoint.toString()); + } } catch (error) { if (mounted) { setState(() { @@ -143,8 +154,11 @@ class _OnboardingFlowState extends State { } void _useDiscovered(DiscoveredServer server) { - _server.text = server.endpoint.toString(); - _continue(); + setState(() { + _server.text = server.endpoint.toString(); + _name.text = server.name; + _error = null; + }); } Future _signIn() async { @@ -241,6 +255,16 @@ class _OnboardingFlowState extends State { Text(lead), const SizedBox(height: 24), field, + if (!_passwordStep) ...[ + const SizedBox(height: 12), + _field( + cupertino, + key: const Key('onboarding-server-name'), + controller: _name, + hint: 'Machine name', + onSubmitted: _continue, + ), + ], if (_error != null) ...[ const SizedBox(height: 8), Text( diff --git a/app/lib/features/settings/saved_server_editor.dart b/app/lib/features/settings/saved_server_editor.dart index 373cfa36..c2728eab 100644 --- a/app/lib/features/settings/saved_server_editor.dart +++ b/app/lib/features/settings/saved_server_editor.dart @@ -4,15 +4,23 @@ import 'package:flutter/material.dart'; import '../../ui/adaptive/segmented_bar.dart'; import '../../core/servers/server_catalog.dart'; import '../../ui/adaptive/host.dart'; +import '../onboarding/discovery/discovered_server.dart'; +import '../onboarding/discovery/discovery_panel.dart'; +import '../onboarding/discovery/server_discovery.dart'; /// When supplied, [onSave] must finish successfully before the route closes. /// Throwing keeps the draft open and displays the error for a retry. Future editSavedServer( BuildContext context, { SavedServer? server, + ServerDiscovery? discovery, Future Function(SavedServer)? onSave, }) { - final page = _ServerEditor(server: server, onSave: onSave); + final page = _ServerEditor( + server: server, + onSave: onSave, + discovery: discovery ?? platformServerDiscovery(), + ); return Navigator.of(context).push( usesCupertinoHost(context) ? CupertinoPageRoute(builder: (_) => page) @@ -21,7 +29,8 @@ Future editSavedServer( } class _ServerEditor extends StatefulWidget { - const _ServerEditor({this.server, this.onSave}); + const _ServerEditor({this.server, this.onSave, this.discovery}); + final ServerDiscovery? discovery; final SavedServer? server; final Future Function(SavedServer)? onSave; @@ -41,6 +50,14 @@ class _ServerEditorState extends State<_ServerEditor> { String? _error; bool _saving = false; + void _useDiscovered(DiscoveredServer server) { + setState(() { + _name.text = server.name; + _addresses.text = server.endpoint.toString(); + _error = null; + }); + } + Future _save() async { if (_saving) return; try { @@ -136,6 +153,14 @@ class _ServerEditorState extends State<_ServerEditor> { child: ListView( padding: const EdgeInsets.all(16), children: [ + if (widget.server == null && widget.discovery != null) ...[ + DiscoveryPanel( + discovery: widget.discovery!, + enabled: !_saving, + onSelect: _useDiscovered, + ), + const SizedBox(height: 16), + ], _field(_name, 'Server name', key: 'server-profile-name'), const SizedBox(height: 16), _field( diff --git a/app/notes/browser-network-discovery.md b/app/notes/browser-network-discovery.md new file mode 100644 index 00000000..86837493 --- /dev/null +++ b/app/notes/browser-network-discovery.md @@ -0,0 +1,16 @@ +# Browser discovery and machine names + +Browser discovery uses the authenticated same-origin `/api/discovery` endpoint, +which browses the hosting server's LAN. Native discovery still uses Bonjour. +Malformed announcements cannot hide valid machines; failed/unsupported discovery +is reported instead of being shown as an empty successful scan. Finite browser +scans stop their progress indicator when the reply arrives. + +Add server now includes discovery, prefills an editable machine name/address, +and saves only after explicit review. Onboarding likewise reviews and persists +the discovered name before probing/signing in. Root wires saveServerProfile. + +Verification: 34 focused discovery/onboarding/saved-server tests passed, including +name editing, no premature connection, browser errors/duplicates/default ports, +and native discovery regressions. Browser captures follow after fixture build; +this note does not yet claim rendered or deployed evidence. diff --git a/app/test/features/onboarding/discovery/browser_server_discovery_test.dart b/app/test/features/onboarding/discovery/browser_server_discovery_test.dart new file mode 100644 index 00000000..3c22d0f0 --- /dev/null +++ b/app/test/features/onboarding/discovery/browser_server_discovery_test.dart @@ -0,0 +1,60 @@ +import 'dart:convert'; +import 'package:flutter_test/flutter_test.dart'; +import 'package:pipelines_app/features/onboarding/discovery/browser_server_discovery.dart'; + +void main() { + test( + 'browser parses names, default ports, auth and deduplicates endpoints', + () async { + final scan = BrowserServerDiscovery( + fetch: () async => jsonEncode({ + 'discovered_servers': [ + { + 'name': 'Linux', + 'endpoint': 'ws://192.168.1.5:8083/connect', + 'auth': 'password', + 'version': 'v1', + }, + { + 'name': 'Linux', + 'endpoint': 'ws://192.168.1.5:8083/connect', + 'auth': 'password', + }, + { + 'name': 'Mac', + 'endpoint': 'wss://mac.local/connect', + 'auth': 'none', + }, + {'name': 'Bad', 'endpoint': 'ws://password@host/connect'}, + {'name': '', 'endpoint': 'ws://host/connect'}, + {'name': 'Fragment', 'endpoint': 'ws://host/connect#secret'}, + ], + }), + ); + final values = await scan.scan().single; + expect(values.map((s) => s.name), ['Linux', 'Mac']); + expect(values.first.passwordRequired, isTrue); + expect(values.last.passwordRequired, isFalse); + expect(values.last.port, 443); + }, + ); + test('unknown and malformed discovery responses report failure', () async { + for (final body in ['not json', '{}', '{"discovered_servers":null}']) { + await expectLater( + BrowserServerDiscovery(fetch: () async => body).scan(), + emitsError(isA()), + ); + } + }); + test( + 'network failure is surfaced instead of pretending no machines exist', + () async { + await expectLater( + BrowserServerDiscovery( + fetch: () async => throw StateError('offline'), + ).scan(), + emitsError(isA()), + ); + }, + ); +} diff --git a/app/test/features/onboarding/discovery/discovered_server_test.dart b/app/test/features/onboarding/discovery/discovered_server_test.dart index 9f2d7099..e3bc3412 100644 --- a/app/test/features/onboarding/discovery/discovered_server_test.dart +++ b/app/test/features/onboarding/discovery/discovered_server_test.dart @@ -61,8 +61,8 @@ void main() { ); }); - test('web has no discovery; native platforms do', () { - expect(platformServerDiscovery(web: true), isNull); + test('web and native platforms provide discovery', () { + expect(platformServerDiscovery(web: true), isNotNull); expect(platformServerDiscovery(web: false), isNotNull); }); } diff --git a/app/test/features/onboarding/discovery/discovery_panel_test.dart b/app/test/features/onboarding/discovery/discovery_panel_test.dart index b95650b6..8dbb2780 100644 --- a/app/test/features/onboarding/discovery/discovery_panel_test.dart +++ b/app/test/features/onboarding/discovery/discovery_panel_test.dart @@ -90,7 +90,7 @@ void main() { expect(find.text('Search again'), findsOneWidget); }); - testWidgets('tapping a server fills the address and connects', ( + testWidgets('tapping a server reviews its name before connecting', ( tester, ) async { await tester.pumpWidget(host(flow(discoverer: discovery))); @@ -101,6 +101,10 @@ void main() { await tester.tap(find.byKey(const Key('discovered-192.168.1.20:8083'))); await tester.pumpAndSettle(); + expect(checked, isEmpty); + await tester.ensureVisible(find.byKey(const Key('onboarding-next'))); + await tester.tap(find.byKey(const Key('onboarding-next'))); + await tester.pumpAndSettle(); final endpoint = Uri.parse('ws://192.168.1.20:8083/connect'); expect(checked, [endpoint]); expect(saved, [endpoint.toString()]); @@ -151,6 +155,10 @@ void main() { expect(find.byType(CupertinoListTile), findsOneWidget); await tester.tap(find.byKey(const Key('discovered-192.168.1.30:8080'))); await tester.pumpAndSettle(); + expect(checked, isEmpty); + await tester.ensureVisible(find.byKey(const Key('onboarding-next'))); + await tester.tap(find.byKey(const Key('onboarding-next'))); + await tester.pumpAndSettle(); expect(checked, [Uri.parse('ws://192.168.1.30:8080/connect')]); }); diff --git a/app/test/features/settings/saved_server_discovery_test.dart b/app/test/features/settings/saved_server_discovery_test.dart new file mode 100644 index 00000000..96797829 --- /dev/null +++ b/app/test/features/settings/saved_server_discovery_test.dart @@ -0,0 +1,124 @@ +import 'dart:convert'; +import 'package:flutter/material.dart'; +import 'package:flutter_test/flutter_test.dart'; +import 'package:pipelines_app/core/servers/server_catalog.dart'; +import 'package:pipelines_app/features/settings/saved_server_editor.dart'; +import 'package:pipelines_app/features/onboarding/discovery/browser_server_discovery.dart'; +import 'package:pipelines_app/features/onboarding/onboarding_flow.dart'; +import 'package:pipelines_app/core/session/server_session.dart'; + +BrowserServerDiscovery discovery() => BrowserServerDiscovery( + fetch: () async => jsonEncode({ + 'discovered_servers': [ + { + 'name': 'Linux laptop', + 'endpoint': 'ws://192.168.1.5:8083/connect', + 'auth': 'password', + }, + ], + }), +); + +void main() { + testWidgets( + 'choosing a discovered machine prefills editable name and address', + (tester) async { + SavedServer? saved; + await tester.pumpWidget( + MaterialApp( + home: Builder( + builder: (context) => Scaffold( + body: TextButton( + onPressed: () => editSavedServer( + context, + discovery: discovery(), + onSave: (value) async { + saved = value; + }, + ), + child: const Text('Add server'), + ), + ), + ), + ), + ); + await tester.tap(find.text('Add server')); + await tester.pumpAndSettle(); + await tester.tap(find.byKey(const Key('discovery-scan'))); + await tester.pumpAndSettle(); + await tester.tap(find.text('Linux laptop')); + await tester.pumpAndSettle(); + expect( + tester + .widget(find.byKey(const Key('server-profile-name'))) + .controller! + .text, + 'Linux laptop', + ); + expect( + tester + .widget( + find.byKey(const Key('server-profile-addresses')), + ) + .controller! + .text, + 'ws://192.168.1.5:8083/connect', + ); + expect(saved, isNull); + await tester.enterText( + find.byKey(const Key('server-profile-name')), + 'My Linux', + ); + await tester.ensureVisible(find.text('Save server')); + await tester.tap(find.text('Save server')); + await tester.pumpAndSettle(); + expect(saved!.name, 'My Linux'); + expect(saved!.endpoints, ['ws://192.168.1.5:8083/connect']); + }, + ); + testWidgets('onboarding reviews and persists machine name before sign-in', ( + tester, + ) async { + var checks = 0; + String? alias; + await tester.pumpWidget( + MaterialApp( + home: OnboardingFlow( + onDone: (_) {}, + discovery: discovery(), + check: (_) async { + checks++; + return SessionState.signedOut; + }, + saveServerProfile: (url, name) async { + alias = name; + }, + ), + ), + ); + await tester.ensureVisible(find.byKey(const Key('discovery-scan'))); + await tester.tap(find.byKey(const Key('discovery-scan'))); + await tester.pumpAndSettle(); + await tester.ensureVisible(find.text('Linux laptop')); + await tester.tap(find.text('Linux laptop')); + await tester.pumpAndSettle(); + expect(checks, 0); + expect( + tester + .widget(find.byKey(const Key('onboarding-server-name'))) + .controller! + .text, + 'Linux laptop', + ); + await tester.enterText( + find.byKey(const Key('onboarding-server-name')), + 'Workstation', + ); + await tester.ensureVisible(find.byKey(const Key('onboarding-next'))); + await tester.tap(find.byKey(const Key('onboarding-next'))); + await tester.pumpAndSettle(); + expect(checks, 1); + expect(alias, 'Workstation'); + expect(find.byKey(const Key('onboarding-password')), findsOneWidget); + }); +} From 89814d9fbe2452da4696d968fc8b3d9dd8f96bff Mon Sep 17 00:00:00 2001 From: Alan Silva Date: Sun, 8 Nov 2026 21:54:20 +0000 Subject: [PATCH 4/6] Record browser discovery capture review and checks --- app/notes/browser-network-discovery.md | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/app/notes/browser-network-discovery.md b/app/notes/browser-network-discovery.md index 86837493..6a2f84e4 100644 --- a/app/notes/browser-network-discovery.md +++ b/app/notes/browser-network-discovery.md @@ -12,5 +12,9 @@ the discovered name before probing/signing in. Root wires saveServerProfile. Verification: 34 focused discovery/onboarding/saved-server tests passed, including name editing, no premature connection, browser errors/duplicates/default ports, -and native discovery regressions. Browser captures follow after fixture build; -this note does not yet claim rendered or deployed evidence. +and native discovery regressions. Analyzer clean (NWAPbG), full-app fixture build passed. Material dark +1280px and Cupertino light560px browsercaptures under +/tmp/review/browser-discovery-{material,cupertino} were inspected: discovered +results and editable selected name/address fit. The fixture served controlled +JSON at /api/discovery; actual backend auth/discovery has separate Node/Go tests. +No production deployment or device testing in this commit. From 349428f11dc948f2a23ce08f892724568fdbad80 Mon Sep 17 00:00:00 2001 From: Alan Silva Date: Sun, 8 Nov 2026 21:57:05 +0000 Subject: [PATCH 5/6] Discover LAN servers and relay authenticated browser peer connections --- docs/cli.md | 10 + docs/notes/browser-discovery-relay.md | 38 +++ internal/discovery/browse.go | 113 ++++++ internal/discovery/browse_test.go | 61 ++++ internal/protocol/message.go | 5 +- internal/protocol/server_discovery.go | 14 + internal/server/server_discovery.go | 51 +++ internal/server/websocket.go | 5 + web/serve.mjs | 26 +- web/src/peerRegistry.js | 180 ++++++++++ web/src/peerRelay.js | 171 ++++++++++ web/src/peerTransport.js | 128 +++++++ web/test/peerRelay.test.mjs | 471 ++++++++++++++++++++++++++ 13 files changed, 1265 insertions(+), 8 deletions(-) create mode 100644 docs/notes/browser-discovery-relay.md create mode 100644 internal/discovery/browse.go create mode 100644 internal/discovery/browse_test.go create mode 100644 internal/protocol/server_discovery.go create mode 100644 internal/server/server_discovery.go create mode 100644 web/src/peerRegistry.js create mode 100644 web/src/peerRelay.js create mode 100644 web/src/peerTransport.js create mode 100644 web/test/peerRelay.test.mjs diff --git a/docs/cli.md b/docs/cli.md index 38344186..35265b70 100644 --- a/docs/cli.md +++ b/docs/cli.md @@ -1265,3 +1265,13 @@ has a 20-second context, bounded Git output/time and file traversal, and at most 100 deletion candidates. Partial scans cannot claim that the storage target has been reached. Cleanup refusals and limits remain visible rather than discarding protected data to satisfy a quota. + + +### LAN server discovery + +`{"type":"discover_servers"}` returns `discovered_servers` with a +`discovered_servers` array of `{name,endpoint,auth,version}` records. The server +browses `_pipelines._tcp.local` on its own LAN, with a bounded DNS-SD query; it +does not scan arbitrary ports. An unavailable browse returns a protocol error. +The authenticated web front door exposes the same result at `GET /api/discovery`, +including before the browser has opened its application websocket. diff --git a/docs/notes/browser-discovery-relay.md b/docs/notes/browser-discovery-relay.md new file mode 100644 index 00000000..d6e8f74c --- /dev/null +++ b/docs/notes/browser-discovery-relay.md @@ -0,0 +1,38 @@ +# Browser discovery and simultaneous server connections + +The server adds a bounded `discover_servers` RPC and local `/discovery` HTTP +handler using its existing mDNS dependency. Advertisements are validated, sorted +and deduplicated; only valid Pipelines `/connect` records are returned. The web +front door exposes this as authenticated `GET /api/discovery`. This searches the +hosting machine's LAN, which can differ from the browser's current network. + +For browser federation, authenticated same-origin `POST /api/peers/:serverId` +accepts `{endpoints:[wsURLs],password?:string}` and responds with `connected`, +`needs_password`, and successful `connected_endpoints`. It signs into each remote +machine directly, retaining cookies only in proxy memory, scoped to the local +login session, server id and exact registered alias. `DELETE` revokes that server. +A proxy restart requires signing into remote peers again; remote harness sessions +and background work are independent and are not stopped by this relay. + +The browser opens `/peers/:serverId/connect?endpoint=` and reads +files/artifacts/updates or uploads through `/peers/:serverId/`, using the +same optional `endpoint` query. These are same-origin paths, so HTTPS browsers can +reach trusted LAN servers without cross-origin cookies or mixed-content sockets. +Local browser cookies and Origin are never forwarded to remote machines; only the +selected peer's exact stored credential is used. No redirects are followed, no +remote Set-Cookie is exposed, and proxying is limited to registered endpoints and +known application resource paths. Mutating registration calls require same Origin +and JSON, and all endpoints remain behind the local login gate. + +New local sessions have unique nonce-bearing signed cookies, while existing +legacy cookies remain valid. Profile edits revoke previous aliases immediately; +registration generations prevent late responses resurrecting deleted profiles. +Failed reauthentication to an unchanged profile preserves its existing cookie and +websocket. Expired owner records close their sockets and are pruned before limits. + +Verification: all 13 Node tests passed, including isolated real HTTP/WS peers, +per-browser and per-server cookie isolation, scoped files and websocket routing, +authenticated discovery, revocation races, failed sign-in preservation, and owner +expiry cleanup. Go discovery/protocol/server tests and focused vet passed. All +fixtures used loopback/scratch state; no operator sessions, passwords, deployments +or workflows were changed. Parent owns Flutter integration and delivery. diff --git a/internal/discovery/browse.go b/internal/discovery/browse.go new file mode 100644 index 00000000..0325b7e1 --- /dev/null +++ b/internal/discovery/browse.go @@ -0,0 +1,113 @@ +package discovery + +import ( + "context" + "io" + "log" + "net" + "net/url" + "sort" + "strconv" + "strings" + "time" + + "github.com/hashicorp/mdns" +) + +// FoundServer is a validated service advertised on the serving host's LAN. +type FoundServer struct { + Name string `json:"name"` + Endpoint string `json:"endpoint"` + Auth string `json:"auth"` + Version string `json:"version"` +} + +// Browse sends one bounded DNS-SD query, never a network port scan. +func Browse(ctx context.Context) ([]FoundServer, error) { + return browse(ctx, mdns.QueryContext) +} + +func browse(ctx context.Context, query func(context.Context, *mdns.QueryParam) error) ([]FoundServer, error) { + ctx, cancel := context.WithTimeout(ctx, 4*time.Second) + defer cancel() + entries := make(chan *mdns.ServiceEntry, 128) + result := make(chan error, 1) + go func() { + result <- query(ctx, &mdns.QueryParam{Service: ServiceType, Domain: "local", Timeout: 3 * time.Second, + Entries: entries, WantUnicastResponse: true, Logger: log.New(io.Discard, "", 0)}) + }() + found := map[string]FoundServer{} + consume := func(entry *mdns.ServiceEntry) { + if item, ok := discovered(entry); ok && len(found) < 128 { + found[item.Endpoint] = item + } + } + for { + select { + case entry := <-entries: + consume(entry) + case err := <-result: + for { + select { + case entry := <-entries: + consume(entry) + default: + values := make([]FoundServer, 0, len(found)) + for _, item := range found { + values = append(values, item) + } + sort.Slice(values, func(i, j int) bool { return values[i].Endpoint < values[j].Endpoint }) + return values, err + } + } + case <-ctx.Done(): + return nil, ctx.Err() + } + } +} + +func discovered(entry *mdns.ServiceEntry) (FoundServer, bool) { + if entry == nil || entry.Port < 1 || entry.Port > 65535 { + return FoundServer{}, false + } + fields := map[string]string{} + for _, value := range entry.InfoFields { + if key, text, ok := strings.Cut(value, "="); ok { + fields[key] = text + } + } + path := fields["path"] + if path != "/connect" { + return FoundServer{}, false + } + ip := entry.AddrV4 + if ip == nil { + ip = entry.AddrV6 + } + if ip == nil && entry.AddrV6IPAddr != nil { + ip = entry.AddrV6IPAddr.IP + } + if ip == nil || ip.IsUnspecified() || ip.IsMulticast() || ip.IsLoopback() || ip.IsLinkLocalUnicast() { + return FoundServer{}, false + } + if fields["tls"] != "0" && fields["tls"] != "1" { + return FoundServer{}, false + } + scheme := "ws" + if fields["tls"] == "1" { + scheme = "wss" + } + auth := fields["auth"] + if auth != "password" && auth != "none" { + return FoundServer{}, false + } + name := strings.TrimSpace(fields["name"]) + if name == "" { + name = strings.TrimSuffix(entry.Host, ".") + } + if name == "" || len(name) > 200 { + return FoundServer{}, false + } + endpoint := (&url.URL{Scheme: scheme, Host: net.JoinHostPort(ip.String(), strconv.Itoa(entry.Port)), Path: path}).String() + return FoundServer{Name: name, Endpoint: endpoint, Auth: auth, Version: fields["v"]}, true +} diff --git a/internal/discovery/browse_test.go b/internal/discovery/browse_test.go new file mode 100644 index 00000000..b0db8fef --- /dev/null +++ b/internal/discovery/browse_test.go @@ -0,0 +1,61 @@ +package discovery + +import ( + "context" + "net" + "testing" + + "github.com/hashicorp/mdns" +) + +func service(ip string) *mdns.ServiceEntry { + return &mdns.ServiceEntry{AddrV4: net.ParseIP(ip), Host: "server.local.", Port: 8083, + InfoFields: []string{"name=Linux desktop", "path=/connect", "tls=0", "auth=password", "v=release"}} +} + +func TestBrowseCollectsDeduplicatedValidAdvertisements(t *testing.T) { + values, err := browse(context.Background(), func(ctx context.Context, p *mdns.QueryParam) error { + if p.Service != ServiceType || p.Timeout.Seconds() > 4 { + t.Fatal("unbounded or wrong service query") + } + for _, entry := range []*mdns.ServiceEntry{service("192.168.1.3"), service("192.168.1.2"), service("192.168.1.3"), service("127.0.0.1"), nil} { + p.Entries <- entry + } + return nil + }) + if err != nil || len(values) != 2 { + t.Fatalf("values=%+v err=%v", values, err) + } + if values[0].Endpoint != "ws://192.168.1.2:8083/connect" || values[0].Name != "Linux desktop" || values[0].Auth != "password" { + t.Fatalf("wrong record: %+v", values[0]) + } +} + +func TestBrowseHonorsCancellation(t *testing.T) { + ctx, cancel := context.WithCancel(context.Background()) + cancel() + _, err := browse(ctx, func(ctx context.Context, p *mdns.QueryParam) error { <-ctx.Done(); return ctx.Err() }) + if err == nil { + t.Fatal("canceled browse must fail") + } +} + +func TestDiscoveryRejectsMalformedAndUnsafeAdvertisements(t *testing.T) { + for _, ip := range []string{"0.0.0.0", "127.0.0.1", "224.0.0.1", "169.254.3.1", "::", "::1", "fe80::1"} { + if _, ok := discovered(service(ip)); ok { + t.Fatalf("accepted address %s", ip) + } + } + for _, fields := range [][]string{{"path=//evil/connect", "auth=password", "tls=0"}, {"path=/connect", "auth=unknown", "tls=0"}, {"path=/connect", "auth=password", "tls=garbage"}} { + item := service("192.168.1.2") + item.InfoFields = fields + if _, ok := discovered(item); ok { + t.Fatalf("accepted invalid TXT %+v", fields) + } + } + item := service("192.168.1.2") + item.Port = 65536 + if _, ok := discovered(item); ok { + t.Fatal("accepted invalid port") + } +} diff --git a/internal/protocol/message.go b/internal/protocol/message.go index 00e21d5f..d65b3820 100644 --- a/internal/protocol/message.go +++ b/internal/protocol/message.go @@ -287,8 +287,9 @@ type Message struct { // AttentionAcks is the ack_attention body, the attention_acks reply (the // whole set) and the attention_acks_changed push (the delta). See // attention_acks.go. - AttentionAcks *AttentionAcks `json:"attention_acks,omitempty"` - ServerStats *ServerStats `json:"server_stats,omitempty"` + AttentionAcks *AttentionAcks `json:"attention_acks,omitempty"` + DiscoveredServers []DiscoveredServer `json:"discovered_servers,omitzero"` + ServerStats *ServerStats `json:"server_stats,omitempty"` // App notification stream (see notifications.go): After is the // subscribe_notifications cursor, Notifications the subscribe reply, // Notification one push, and IDs the clear_notifications request, the diff --git a/internal/protocol/server_discovery.go b/internal/protocol/server_discovery.go new file mode 100644 index 00000000..c00d5264 --- /dev/null +++ b/internal/protocol/server_discovery.go @@ -0,0 +1,14 @@ +package protocol + +const ( + DiscoverServersRequest = "discover_servers" + DiscoverServersResult = "discovered_servers" +) + +// DiscoveredServer is one Pipelines DNS-SD advertisement on the serving LAN. +type DiscoveredServer struct { + Name string `json:"name"` + Endpoint string `json:"endpoint"` + Auth string `json:"auth"` + Version string `json:"version"` +} diff --git a/internal/server/server_discovery.go b/internal/server/server_discovery.go new file mode 100644 index 00000000..0a5448e9 --- /dev/null +++ b/internal/server/server_discovery.go @@ -0,0 +1,51 @@ +package server + +import ( + "context" + "encoding/json" + "net/http" + "time" + + "git.a-wan.net/alan/pipelines/internal/discovery" + "git.a-wan.net/alan/pipelines/internal/protocol" +) + +var discoverySlots = make(chan struct{}, 4) + +func discoverServers(ctx context.Context) ([]discovery.FoundServer, error) { + ctx, cancel := context.WithTimeout(ctx, 4*time.Second) + defer cancel() + select { + case discoverySlots <- struct{}{}: + defer func() { <-discoverySlots }() + return discovery.Browse(ctx) + case <-ctx.Done(): + return nil, ctx.Err() + } +} + +func handleServerDiscovery(ctx context.Context, request protocol.Message, write func(protocol.Message) error) { + servers, err := discoverServers(ctx) + if err != nil { + _ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "LAN discovery unavailable: " + err.Error()}) + return + } + items := make([]protocol.DiscoveredServer, 0, len(servers)) + for _, server := range servers { + items = append(items, protocol.DiscoveredServer(server)) + } + _ = write(protocol.Message{Type: protocol.DiscoverServersResult, ID: request.ID, DiscoveredServers: items}) +} + +func serveServerDiscovery(w http.ResponseWriter, r *http.Request) { + servers, err := discoverServers(r.Context()) + w.Header().Set("Cache-Control", "no-store") + w.Header().Set("Content-Type", "application/json") + if err != nil { + http.Error(w, "LAN discovery unavailable", http.StatusServiceUnavailable) + return + } + _ = json.NewEncoder(w).Encode(struct { + Servers []discovery.FoundServer `json:"discovered_servers"` + }{servers}) +} diff --git a/internal/server/websocket.go b/internal/server/websocket.go index 1b6f752c..a32c1034 100644 --- a/internal/server/websocket.go +++ b/internal/server/websocket.go @@ -153,6 +153,7 @@ func HandlerWithOptions(ctx context.Context, options Options, stores ...*pipelin } runs.serveArtifact(w, r) }) + mux.HandleFunc("GET /discovery", serveServerDiscovery) mux.HandleFunc("GET /files", serveHomeFile) mux.HandleFunc("POST /chat-uploads", serveChatUpload) mux.HandleFunc("GET /healthz", func(w http.ResponseWriter, r *http.Request) { @@ -276,6 +277,10 @@ func HandlerWithOptions(ctx context.Context, options Options, stores ...*pipelin if handleDirectoryListing(request, write) { continue } + if request.Type == protocol.DiscoverServersRequest { + go handleServerDiscovery(connCtx, request, write) + continue + } if request.Type == protocol.ServerStatsRequest { go handleServerStats(connCtx, request, runs, options.ServerStatsSampler, started, build, write) continue diff --git a/web/serve.mjs b/web/serve.mjs index fe7354a8..1f8e316d 100644 --- a/web/serve.mjs +++ b/web/serve.mjs @@ -18,7 +18,7 @@ // // The default host is 127.0.0.1. Use --host 0.0.0.0 only on a trusted LAN/VPN. import { createServer, request } from "node:http"; -import { createHmac, timingSafeEqual } from "node:crypto"; +import { createHmac, timingSafeEqual, randomBytes } from "node:crypto"; import { createReadStream, readFileSync } from "node:fs"; import { homedir } from "node:os"; import { readFile, stat } from "node:fs/promises"; @@ -26,6 +26,7 @@ import { extname, join, normalize, resolve, sep } from "node:path"; import { fileURLToPath } from "node:url"; import net from "node:net"; import { sameOriginUpgrade } from "./src/proxySecurity.js"; +import { PeerRelay, proxyDiscovery } from "./src/peerRelay.js"; // The proxy's own directory holds the sign-in page's icons. const HERE = resolve(fileURLToPath(new URL(".", import.meta.url))); @@ -86,7 +87,8 @@ function cookieValue(req, name) { } function signSession(expires) { - return `${expires}.${createHmac("sha256", auth.secret).update(String(expires)).digest("base64url")}`; + const payload = `${expires}.${randomBytes(18).toString("base64url")}`; + return `${payload}.${createHmac("sha256", auth.secret).update(payload).digest("base64url")}`; } const SESSION_LONG_SECONDS = 30 * 24 * 60 * 60; @@ -99,9 +101,11 @@ function sessionToken(remember = false) { function validSession(value) { if (!auth || typeof value !== "string") return false; - const [expires, signature] = value.split("."); - if (!expires || !signature) return false; - const expected = createHmac("sha256", auth.secret).update(expires).digest(); + const parts = value.split("."); + if (parts.length !== 2 && parts.length !== 3) return false; + const expires = parts[0], signature = parts.at(-1); + if (!/^\d+$/.test(expires) || !signature) return false; + const expected = createHmac("sha256", auth.secret).update(parts.slice(0, -1).join(".")).digest(); let given; try { given = Buffer.from(signature, "base64url"); @@ -116,6 +120,8 @@ function isAuthed(req) { return !auth || validSession(cookieValue(req, SESSION_COOKIE)); } +const peerRelay = new PeerRelay((req) => AUTH_DISABLED ? "test-auth-disabled" : cookieValue(req, SESSION_COOKIE)); + function passwordOk(candidate) { if (!auth) return true; const given = Buffer.from(String(candidate ?? "")); @@ -439,12 +445,13 @@ const server = createServer(async (req, res) => { res.writeHead(303, { Location: safeNext(fields.get("next")) }).end(); return; } else if (pathname === "/logout") { + peerRelay.forget(req); res.setHeader("Set-Cookie", `${SESSION_COOKIE}=; Path=/; HttpOnly; SameSite=Strict; Max-Age=0`); res.writeHead(303, { Location: "/login" }).end(); return; } else if (!isAuthed(req)) { const wantsHtml = String(req.headers.accept ?? "").includes("text/html"); - if (req.method === "GET" && wantsHtml) { + if (req.method === "GET" && wantsHtml && !pathname.startsWith("/api/") && !pathname.startsWith("/peers/")) { res.writeHead(302, { Location: `/login?next=${encodeURIComponent(req.url ?? "/")}` }).end(); return; } @@ -454,6 +461,12 @@ const server = createServer(async (req, res) => { return; } } + if (pathname === "/api/discovery" && req.method === "GET") { + await proxyDiscovery(req, res, targetHost, targetPort); + return; + } + if (await peerRelay.api(req, res)) return; + if (peerRelay.http(req, res)) return; if (pathname.startsWith("/artifacts/") || pathname === "/files") { proxyArtifact(req, res); return; @@ -563,6 +576,7 @@ server.on("upgrade", (req, clientSocket, clientHead) => { clientSocket.destroy(); return; } + if (peerRelay.upgrade(req, clientSocket, clientHead)) return; if (pathname !== "/connect") { clientSocket.destroy(); return; diff --git a/web/src/peerRegistry.js b/web/src/peerRegistry.js new file mode 100644 index 00000000..6af2a649 --- /dev/null +++ b/web/src/peerRegistry.js @@ -0,0 +1,180 @@ +import { createHash } from "node:crypto"; +import { authenticate, endpoint, json } from "./peerTransport.js"; +import { sameOriginUpgrade } from "./proxySecurity.js"; + +async function body(req) { + const chunks = []; + let size = 0; + for await (const chunk of req) { + size += chunk.length; + if (size > 65536) throw new Error("Request too large"); + chunks.push(chunk); + } + return JSON.parse(Buffer.concat(chunks).toString("utf8")); +} + +export class PeerRegistry { + constructor(scopeFor) { + this.scopeFor = scopeFor; + this.sessions = new Map(); + } + owner(req) { + const token = this.scopeFor(req); + if (!token) throw new Error("Sign in first"); + const key = createHash("sha256").update(token).digest("hex"); + for (const [old, value] of this.sessions) { + if (Date.now() - value.used > 12 * 3600000) { + for (const peer of value.peers.values()) + for (const socket of peer.sockets) socket.destroy(); + this.sessions.delete(old); + } + } + if (!this.sessions.has(key)) { + if (this.sessions.size >= 256) + throw new Error("Too many browser sessions"); + this.sessions.set(key, { + peers: new Map(), + versions: new Map(), + used: Date.now(), + }); + } + const owner = this.sessions.get(key); + owner.used = Date.now(); + return owner; + } + forget(req) { + try { + const token = this.scopeFor(req); + if (!token) return; + const key = createHash("sha256").update(token).digest("hex"); + const owner = this.sessions.get(key); + if (!owner) return; + for (const peer of owner.peers.values()) + for (const socket of peer.sockets) socket.destroy(); + this.sessions.delete(key); + } catch {} + } + async api(req, res) { + const parsed = new URL(req.url, "http://localhost"); + const match = /^\/api\/peers\/([^/]+)$/.exec(parsed.pathname); + if (!match) return false; + if ( + !sameOriginUpgrade(req.headers.origin, req.headers.host) || + (["POST", "DELETE"].includes(req.method) && !req.headers.origin) + ) { + json(res, 403, { error: "Same-origin request required" }); + return true; + } + try { + const id = decodeURIComponent(match[1]); + if (!id || id.length > 256) throw new Error("Invalid server id"); + const owner = this.owner(req); + if (req.method === "DELETE") { + owner.versions.set(id, (owner.versions.get(id) ?? 0) + 1); + const previous = owner.peers.get(id); + if (previous) for (const socket of previous.sockets) socket.destroy(); + owner.peers.delete(id); + json(res, 200, { connected: false, needs_password: false }); + return true; + } + if (req.method === "GET") { + const peer = owner.peers.get(id); + json(res, 200, { + connected: Boolean(peer?.connected), + needs_password: !peer?.connected, + }); + return true; + } + if ( + req.method !== "POST" || + !String(req.headers["content-type"]).startsWith("application/json") + ) { + json(res, 405, { error: "POST JSON required" }); + return true; + } + const data = await body(req); + if ( + !Array.isArray(data.endpoints) || + data.endpoints.length < 1 || + data.endpoints.length > 8 || + (data.password !== undefined && + (typeof data.password !== "string" || data.password.length > 4096)) + ) + throw new Error("Invalid server addresses"); + const urls = [ + ...new Set(data.endpoints.map((value) => endpoint(value).href)), + ]; + const previous = owner.peers.get(id); + if (!previous && owner.peers.size >= 64) + throw new Error("Too many saved servers"); + const sameEndpoints = + previous && + previous.endpoints.length === urls.length && + urls.every((url) => previous.endpoints.includes(url)); + const version = (owner.versions.get(id) ?? 0) + 1; + owner.versions.set(id, version); + if (previous && !sameEndpoints) { + for (const socket of previous.sockets) socket.destroy(); + owner.peers.delete(id); + } + const peer = { + endpoints: urls, + cookies: new Map(), + sockets: new Set(), + connected: false, + active: urls[0], + }; + const results = await Promise.all( + urls.map(async (value) => { + try { + const old = previous?.endpoints.includes(value) + ? (previous.cookies.get(value) ?? "") + : ""; + const status = await authenticate( + new URL(value), + old, + data.password, + ); + if (status.connected) { + peer.cookies.set(value, status.cookie); + peer.active = value; + peer.connected = true; + } + return status; + } catch { + return { connected: false, needs_password: false }; + } + }), + ); + if (owner.versions.get(id) !== version) { + json(res, 409, { error: "Server selection changed during sign-in" }); + return true; + } + if (sameEndpoints && !peer.connected) { + json(res, 200, { + connected: false, + needs_password: results.some((r) => r.needs_password), + previous_connection_kept: true, + error: "Sign-in failed. The existing connection was kept.", + }); + return true; + } + if (sameEndpoints) peer.sockets = previous.sockets; + owner.peers.set(id, peer); + json(res, 200, { + connected_endpoints: [...peer.cookies.keys()], + connected: peer.connected, + needs_password: + !peer.connected && results.some((r) => r.needs_password), + ...(!peer.connected && !results.some((r) => r.needs_password) + ? { error: "Server could not be reached" } + : {}), + }); + } catch { + json(res, 400, { + error: "Server registration failed. Check the addresses and sign-in.", + }); + } + return true; + } +} diff --git a/web/src/peerRelay.js b/web/src/peerRelay.js new file mode 100644 index 00000000..d0fcf58c --- /dev/null +++ b/web/src/peerRelay.js @@ -0,0 +1,171 @@ +import { + endpoint, + webOrigin, + boundedRequest, + remoteRequest, + json, +} from "./peerTransport.js"; +import { PeerRegistry } from "./peerRegistry.js"; + +const allowed = (path) => + path === "/files" || + path === "/chat-uploads" || + path.startsWith("/artifacts/") || + path.startsWith("/updates/"); +export class PeerRelay extends PeerRegistry { + target(req, path) { + const parsed = new URL(req.url, "http://localhost"); + const match = /^\/peers\/([^/]+)\/(.*)$/.exec(parsed.pathname); + if (!match) return null; + const owner = this.owner(req); + const peer = owner.peers.get(decodeURIComponent(match[1])); + if (!peer) throw new Error("Select and sign in to this server again"); + const selected = endpoint( + parsed.searchParams.get("endpoint") ?? peer.active, + ).href; + if (!peer.endpoints.includes(selected) || !peer.cookies.has(selected)) + throw new Error("Server address is not signed in"); + parsed.searchParams.delete("endpoint"); + const url = new URL(path ?? `/${match[2]}`, webOrigin(selected)); + url.search = parsed.search; + if (url.origin !== webOrigin(selected).origin) + throw new Error("Remote origin changed"); + return { url, cookie: peer.cookies.get(selected), peer }; + } + http(req, res) { + if (!req.url.startsWith("/peers/")) return false; + try { + const target = this.target(req); + if ( + !target || + !allowed(target.url.pathname) || + !["GET", "HEAD", "POST"].includes(req.method) || + (req.method === "POST" && target.url.pathname !== "/chat-uploads") + ) { + json(res, 404, { error: "Unsupported remote resource" }); + return true; + } + const headers = { ...(target.cookie ? { cookie: target.cookie } : {}) }; + for (const name of [ + "content-type", + "content-length", + "range", + "x-file-name", + "x-upload-name", + "x-chat-file-name", + "x-pipelines-upload-name", + ]) + if (req.headers[name]) headers[name] = req.headers[name]; + const upstream = remoteRequest(target.url, { + method: req.method, + headers, + }); + upstream.setTimeout(30000, () => upstream.destroy()); + upstream.on("response", (response) => { + const safe = {}; + for (const name of [ + "content-type", + "content-length", + "content-range", + "accept-ranges", + "content-disposition", + ]) + if (response.headers[name]) safe[name] = response.headers[name]; + res.writeHead( + response.statusCode >= 300 && response.statusCode < 400 + ? 502 + : response.statusCode, + { ...safe, "Cache-Control": "no-store" }, + ); + response.pipe(res); + }); + upstream.on("error", () => { + if (!res.headersSent) + json(res, 502, { error: "Remote server unavailable" }); + else res.destroy(); + }); + req.on("aborted", () => upstream.destroy()); + res.on("close", () => upstream.destroy()); + req.pipe(upstream); + } catch { + json(res, 401, { error: "Sign in to the remote server again" }); + } + return true; + } + upgrade(req, socket, head) { + if (!req.url.startsWith("/peers/")) return false; + try { + const target = this.target(req, "/connect"); + const headers = { + host: target.url.host, + connection: "Upgrade", + upgrade: "websocket", + "sec-websocket-key": req.headers["sec-websocket-key"], + "sec-websocket-version": "13", + ...(target.cookie ? { cookie: target.cookie } : {}), + }; + const upstream = remoteRequest(target.url, { headers }); + upstream.setTimeout(10000, () => upstream.destroy()); + upstream.on("upgrade", (response, remote, remoteHead) => { + socket.write( + `HTTP/1.1 101 Switching Protocols\r\n${Object.entries( + response.headers, + ) + .filter(([k]) => + [ + "upgrade", + "connection", + "sec-websocket-accept", + "sec-websocket-protocol", + ].includes(k), + ) + .map(([k, v]) => `${k}: ${v}`) + .join("\r\n")}\r\n\r\n`, + ); + target.peer.sockets.add(socket); + remote.setTimeout(0); + socket.once("close", () => { + target.peer.sockets.delete(socket); + remote.destroy(); + }); + remote.once("close", () => socket.destroy()); + socket.on("error", () => remote.destroy()); + remote.on("error", () => socket.destroy()); + if (head?.length) remote.write(head); + if (remoteHead?.length) socket.write(remoteHead); + remote.pipe(socket); + socket.pipe(remote); + }); + upstream.on("response", (response) => { + response.resume(); + socket.end( + `HTTP/1.1 ${response.statusCode === 401 ? 401 : 502} Remote Unavailable\r\nContent-Length: 0\r\n\r\n`, + ); + }); + upstream.on("error", () => socket.destroy()); + socket.once("close", () => upstream.destroy()); + upstream.end(); + } catch { + socket.end("HTTP/1.1 401 Unauthorized\r\nContent-Length: 0\r\n\r\n"); + } + return true; + } +} + +export async function proxyDiscovery(req, res, host, port) { + try { + const response = await boundedRequest( + new URL( + `http://${host.includes(":") ? `[${host}]` : host}:${port}/discovery`, + ), + ); + res + .writeHead(response.status, { + "Content-Type": "application/json", + "Cache-Control": "no-store", + }) + .end(response.body); + } catch { + json(res, 503, { error: "LAN discovery unavailable" }); + } +} diff --git a/web/src/peerTransport.js b/web/src/peerTransport.js new file mode 100644 index 00000000..ffcbc2f7 --- /dev/null +++ b/web/src/peerTransport.js @@ -0,0 +1,128 @@ +import http from "node:http"; +import https from "node:https"; + +export function endpoint(value) { + const url = new URL(value); + if ( + !["ws:", "wss:"].includes(url.protocol) || + !url.hostname || + url.username || + url.password || + url.hash || + url.search || + url.pathname !== "/connect" + ) + throw new Error("Use a ws(s) server address ending in /connect"); + return url; +} +export function webOrigin(url) { + const result = new URL(url); + result.protocol = result.protocol === "wss:" ? "https:" : "http:"; + result.pathname = "/"; + return result; +} +export function remoteRequest(url, options = {}) { + return (url.protocol === "https:" ? https : http).request(url, options); +} + +// Never follows redirects or sends local browser cookies to another machine. +export function boundedRequest( + url, + { method = "GET", cookie = "", body = "", headers = {} } = {}, +) { + return new Promise((resolve, reject) => { + const request = remoteRequest(url, { + method, + headers: { ...headers, ...(cookie ? { Cookie: cookie } : {}) }, + }); + const timer = setTimeout( + () => request.destroy(new Error("Server timed out")), + 8000, + ); + request.once("error", (error) => { + clearTimeout(timer); + reject(error); + }); + request.once("response", (response) => { + const chunks = []; + let bytes = 0; + response.on("data", (chunk) => { + bytes += chunk.length; + if (bytes > 65536) { + response.destroy(); + request.destroy(new Error("Server response was too large")); + return; + } + chunks.push(chunk); + }); + response.once("error", (error) => { + clearTimeout(timer); + reject(error); + }); + response.once("end", () => { + clearTimeout(timer); + resolve({ + status: response.statusCode, + headers: response.headers, + body: Buffer.concat(chunks).toString("utf8"), + }); + }); + }); + request.end(body); + }); +} + +export function sessionCookie(response) { + return (response.headers["set-cookie"] ?? []) + .map((value) => value.split(";")[0]) + .filter((value) => value.startsWith("pipelines_session=")) + .join("; "); +} + +export async function authenticate(url, cookie, password) { + const login = new URL("/login", webOrigin(url)); + let response; + if (password !== undefined) { + const body = new URLSearchParams({ password, remember: "on" }).toString(); + response = await boundedRequest(login, { + method: "POST", + body, + cookie, + headers: { + "Content-Type": "application/x-www-form-urlencoded", + "Content-Length": Buffer.byteLength(body), + }, + }); + if ([302, 303].includes(response.status)) { + cookie = sessionCookie(response) || cookie; + } else if (response.status === 401 || response.status === 429) { + return { connected: false, needs_password: true, cookie: "" }; + } + } + response = await boundedRequest(login, { cookie }); + if ([302, 303].includes(response.status)) + return { connected: true, needs_password: false, cookie }; + if ( + response.status === 401 || + (response.status === 200 && /name=["']password["']/.test(response.body)) + ) { + return { connected: false, needs_password: true, cookie: "" }; + } + if (response.status === 200) + return { connected: true, needs_password: false, cookie }; + if (response.status === 404) { + const health = await boundedRequest(new URL("/healthz", webOrigin(url))); + if (health.status === 200 && JSON.parse(health.body)?.healthy === true) + return { connected: true, needs_password: false, cookie: "" }; + } + throw new Error("Server could not be reached"); +} + +export function json(res, status, value) { + res + .writeHead(status, { + "Content-Type": "application/json", + "Cache-Control": "no-store", + }) + .end(JSON.stringify(value)); +} diff --git a/web/test/peerRelay.test.mjs b/web/test/peerRelay.test.mjs new file mode 100644 index 00000000..210995a0 --- /dev/null +++ b/web/test/peerRelay.test.mjs @@ -0,0 +1,471 @@ +import test from "node:test"; +import assert from "node:assert/strict"; +import { createServer, request } from "node:http"; +import { createHash, randomBytes } from "node:crypto"; +import { once } from "node:events"; +import { mkdtemp, writeFile, rm } from "node:fs/promises"; +import { tmpdir } from "node:os"; +import { join } from "node:path"; +import { PeerRegistry } from "../src/peerRegistry.js"; +import { spawn } from "node:child_process"; +import { fileURLToPath } from "node:url"; + +async function fixture(t) { + const observations = []; + const gates = {}; + const hold = (name) => { + let release, enter; + const promise = new Promise((done) => { + release = done; + }); + const entered = new Promise((done) => { + enter = done; + }); + gates[name] = { promise, enter }; + t.after(release); + return { entered, release }; + }; + const remotes = []; + for (const name of ["one", "two"]) { + const server = createServer(async (req, res) => { + observations.push({ + name, + path: req.url, + cookie: req.headers.cookie, + upload: req.headers["x-pipelines-upload-name"], + }); + if (req.url === "/login" && req.method === "GET" && gates[name]) { + gates[name].enter(); + await gates[name].promise; + } + if (req.url === "/discovery") { + res.setHeader("Content-Type", "application/json"); + res.end( + JSON.stringify({ + discovered_servers: [ + { + name: "Linux desktop", + endpoint: "ws://192.168.1.2:8083/connect", + auth: "password", + version: "test", + }, + ], + }), + ); + return; + } + if (req.url === "/login" && req.method === "POST") { + let body = ""; + for await (const chunk of req) body += chunk; + if (new URLSearchParams(body).get("password") !== `password-${name}`) { + res.writeHead(401).end(); + return; + } + res + .writeHead(303, { + "Set-Cookie": `pipelines_session=remote-${name}; HttpOnly`, + Location: "/", + }) + .end(); + return; + } + if (req.url === "/login") { + if (req.headers.cookie === `pipelines_session=remote-${name}`) + res.writeHead(302, { Location: "/" }).end(); + else res.end(''); + return; + } + res.setHeader("Set-Cookie", "do-not-forward=private"); + res.end( + JSON.stringify({ name, url: req.url, cookie: req.headers.cookie }), + ); + }); + server.on("upgrade", (req, socket) => { + observations.push({ + name, + path: req.url, + cookie: req.headers.cookie, + origin: req.headers.origin, + }); + if (req.headers.cookie !== `pipelines_session=remote-${name}`) { + socket.end("HTTP/1.1 401 Unauthorized\r\nContent-Length: 0\r\n\r\n"); + return; + } + const accept = createHash("sha1") + .update( + req.headers["sec-websocket-key"] + + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11", + ) + .digest("base64"); + socket.write( + `HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Accept: ${accept}\r\n\r\n`, + ); + const message = Buffer.from(JSON.stringify({ name })); + socket.write( + Buffer.concat([Buffer.from([0x81, message.length]), message]), + ); + socket.on("error", () => {}); + }); + server.listen(0, "127.0.0.1"); + await once(server, "listening"); + t.after(() => { + server.closeAllConnections(); + server.close(); + }); + remotes.push(`ws://127.0.0.1:${server.address().port}/connect`); + } + const dir = await mkdtemp(join(tmpdir(), "peer-relay-")); + t.after(() => rm(dir, { recursive: true, force: true })); + const auth = join(dir, "auth.json"); + await writeFile( + auth, + JSON.stringify({ password: "local-password", secret: "s".repeat(40) }), + ); + const reserve = createServer().listen(0, "127.0.0.1"); + await once(reserve, "listening"); + const port = reserve.address().port; + await new Promise((done) => reserve.close(done)); + const child = spawn( + process.execPath, + [ + "serve.mjs", + "--port", + String(port), + "--pipelines", + new URL(remotes[0]).host, + ], + { + cwd: fileURLToPath(new URL("..", import.meta.url)), + env: { + ...process.env, + PIPELINES_WEB_AUTH: "", + PIPELINES_WEB_AUTH_FILE: auth, + }, + stdio: ["ignore", "pipe", "inherit"], + }, + ); + t.after(async () => { + const exited = once(child, "exit"); + child.kill(); + await exited; + }); + await once(child.stdout, "data"); + const base = `http://127.0.0.1:${port}`; + const login = async () => { + const reply = await fetch(base + "/login", { + method: "POST", + body: new URLSearchParams({ password: "local-password" }), + redirect: "manual", + }); + return reply.headers.get("set-cookie").split(";")[0]; + }; + const cookie = await login(); + const register = (id, data, who = cookie, origin = base) => + fetch(base + "/api/peers/" + id, { + method: "POST", + headers: { + Cookie: who, + Origin: origin, + "Content-Type": "application/json", + }, + body: JSON.stringify(data), + }); + return { base, cookie, remotes, observations, register, login, hold }; +} + +test("browser can authenticate both machines, relay files and keep local credentials isolated", async (t) => { + const f = await fixture(t); + assert.equal( + (await f.register("one", { endpoints: [f.remotes[0]] }, "")).status, + 401, + ); + const needing = await f.register("one", { endpoints: [f.remotes[0]] }); + assert.equal((await needing.json()).needs_password, true); + assert.equal( + ( + await ( + await f.register("one", { + endpoints: [f.remotes[0]], + password: "password-one", + }) + ).json() + ).connected, + true, + ); + assert.equal( + ( + await ( + await f.register("two", { + endpoints: [f.remotes[1]], + password: "password-two", + }) + ).json() + ).connected, + true, + ); + for (const [id, name] of [ + ["one", "one"], + ["two", "two"], + ]) { + const reply = await fetch( + f.base + `/peers/${id}/files?path=%2Fhome%2Freport`, + { headers: { Cookie: f.cookie } }, + ); + assert.equal(reply.status, 200); + assert.equal(reply.headers.get("set-cookie"), null); + assert.deepEqual(await reply.json(), { + name, + url: "/files?path=%2Fhome%2Freport", + cookie: `pipelines_session=remote-${name}`, + }); + } + const otherCookie = await f.login(); + assert.notEqual(otherCookie, f.cookie); + assert.equal( + ( + await fetch(f.base + "/peers/one/files", { + headers: { Cookie: otherCookie }, + }) + ).status, + 401, + ); + assert.equal( + ( + await f.register( + "one", + { endpoints: [f.remotes[0]], password: "password-one" }, + f.cookie, + "http://evil.test", + ) + ).status, + 403, + ); + assert.equal( + ( + await f.register("bad", { + endpoints: ["ws://user:secret@localhost/connect"], + }) + ).status, + 400, + ); + assert.equal( + ( + await fetch(f.base + "/peers/one//evil.test/files", { + headers: { Cookie: f.cookie }, + }) + ).status, + 401, + ); + assert.equal( + ( + await fetch(f.base + "/peers/one/other", { + headers: { Cookie: f.cookie }, + }) + ).status, + 404, + ); + assert.equal( + f.observations.some((x) => x.cookie === f.cookie), + false, + ); +}); + +test("websocket relay authenticates the chosen machine without forwarding browser Origin", async (t) => { + const f = await fixture(t); + await f.register("two", { + endpoints: [f.remotes[1]], + password: "password-two", + }); + const result = await new Promise((resolve, reject) => { + const req = request( + f.base + + "/peers/two/connect?endpoint=" + + encodeURIComponent(f.remotes[1]), + { + headers: { + Cookie: f.cookie, + Origin: f.base, + Connection: "Upgrade", + Upgrade: "websocket", + "Sec-WebSocket-Key": randomBytes(16).toString("base64"), + "Sec-WebSocket-Version": "13", + }, + }, + ); + req.on("upgrade", (res, socket, head) => { + const receive = (chunk) => { + socket.destroy(); + resolve({ status: res.statusCode, text: chunk.subarray(2).toString() }); + }; + if (head.length) receive(head); + else socket.once("data", receive); + }); + req.on("response", (res) => reject(new Error(String(res.statusCode)))); + req.on("error", reject); + req.end(); + }); + assert.equal(result.status, 101); + assert.deepEqual(JSON.parse(result.text), { name: "two" }); + const observed = f.observations.find( + (x) => x.name === "two" && x.path === "/connect", + ); + assert.equal(observed.cookie, "pipelines_session=remote-two"); + assert.equal(observed.origin, undefined); +}); + +test("removing or changing a profile revokes its previous remote route", async (t) => { + const f = await fixture(t); + await f.register("server", { + endpoints: [f.remotes[0]], + password: "password-one", + }); + await f.register("server", { + endpoints: [f.remotes[1]], + password: "password-two", + }); + assert.equal( + ( + await fetch( + f.base + + "/peers/server/files?endpoint=" + + encodeURIComponent(f.remotes[0]), + { headers: { Cookie: f.cookie } }, + ) + ).status, + 401, + ); + const removed = await fetch(f.base + "/api/peers/server", { + method: "DELETE", + headers: { Cookie: f.cookie, Origin: f.base }, + }); + assert.equal(removed.status, 200); + assert.equal( + ( + await fetch(f.base + "/peers/server/files", { + headers: { Cookie: f.cookie }, + }) + ).status, + 401, + ); +}); + +test("browser discovery is authenticated and served from the hosting machine", async (t) => { + const f = await fixture(t); + assert.equal((await fetch(f.base + "/api/discovery")).status, 401); + const result = await fetch(f.base + "/api/discovery", { + headers: { Cookie: f.cookie }, + }); + assert.equal(result.status, 200); + assert.equal( + (await result.json()).discovered_servers[0].name, + "Linux desktop", + ); + assert.equal(f.observations.filter((x) => x.path === "/discovery").length, 1); +}); + +test("failed password retry keeps the previous authenticated route and socket", async (t) => { + const f = await fixture(t); + await f.register("one", { + endpoints: [f.remotes[0]], + password: "password-one", + }); + const live = await new Promise((resolve, reject) => { + const req = request(f.base + "/peers/one/connect", { + headers: { + Cookie: f.cookie, + Origin: f.base, + Connection: "Upgrade", + Upgrade: "websocket", + "Sec-WebSocket-Key": randomBytes(16).toString("base64"), + "Sec-WebSocket-Version": "13", + }, + }); + req.on("upgrade", (res, socket) => resolve(socket)); + req.on("response", (res) => reject(new Error(String(res.statusCode)))); + req.on("error", reject); + req.end(); + }); + t.after(() => live.destroy()); + const failed = await f.register("one", { + endpoints: [f.remotes[0]], + password: "wrong-password", + }); + const status = await failed.json(); + assert.equal(status.previous_connection_kept, true); + assert.equal(status.needs_password, true); + const file = await fetch(f.base + "/peers/one/files", { + headers: { Cookie: f.cookie }, + }); + assert.equal(file.status, 200); + assert.equal((await file.json()).cookie, "pipelines_session=remote-one"); + assert.equal(live.destroyed, false); +}); + +test("changed aliases revoke immediately and late sign-in cannot resurrect a deleted profile", async (t) => { + const f = await fixture(t); + await f.register("server", { + endpoints: [f.remotes[0]], + password: "password-one", + }); + const gate = f.hold("two"); + const changing = f.register("server", { + endpoints: [f.remotes[1]], + password: "password-two", + }); + await gate.entered; + assert.equal( + ( + await fetch( + f.base + + "/peers/server/files?endpoint=" + + encodeURIComponent(f.remotes[0]), + { headers: { Cookie: f.cookie } }, + ) + ).status, + 401, + ); + await fetch(f.base + "/api/peers/server", { + method: "DELETE", + headers: { Cookie: f.cookie, Origin: f.base }, + }); + gate.release(); + assert.equal((await changing).status, 409); + assert.equal( + ( + await fetch(f.base + "/peers/server/files", { + headers: { Cookie: f.cookie }, + }) + ).status, + 401, + ); +}); + +test("expired registry owners are closed and pruned before the capacity check", () => { + const registry = new PeerRegistry((req) => req.token); + let closed = 0; + for (let i = 0; i < 256; i++) + registry.sessions.set(String(i), { + used: 0, + versions: new Map(), + peers: new Map([ + [ + "x", + { + sockets: new Set([ + { + destroy() { + closed++; + }, + }, + ]), + }, + ], + ]), + }); + registry.owner({ token: "new-session" }); + assert.equal(closed, 256); + assert.equal(registry.sessions.size, 1); + const before = registry.sessions.size; + registry.forget({ token: "unknown-invalid-session" }); + assert.equal(registry.sessions.size, before); +}); From 497cd66a1e8a53fcc83ba53587a1ee4a0d007c03 Mon Sep 17 00:00:00 2001 From: Alan Silva Date: Sun, 8 Nov 2026 22:01:09 +0000 Subject: [PATCH 6/6] Keep browser chat server connections together in saved-server settings --- .../features/settings/saved_server_row.dart | 23 +++++++-- .../settings/saved_servers_section.dart | 24 ++++++++-- app/notes/browser-network-discovery.md | 6 +++ .../settings/saved_server_discovery_test.dart | 47 +++++++++++++++++++ .../settings/settings_layout_test.dart | 2 +- 5 files changed, 92 insertions(+), 10 deletions(-) diff --git a/app/lib/features/settings/saved_server_row.dart b/app/lib/features/settings/saved_server_row.dart index af928c24..b86722b4 100644 --- a/app/lib/features/settings/saved_server_row.dart +++ b/app/lib/features/settings/saved_server_row.dart @@ -23,21 +23,27 @@ class SavedServerRow extends StatelessWidget { required this.selected, required this.busy, required this.onAction, + this.allowSelection = true, + this.primaryContext = false, }); + final bool allowSelection, primaryContext; final SavedServer server; final bool selected; final bool busy; final ValueChanged onAction; String _label(SavedServerAction action) => switch (action) { - SavedServerAction.use => 'Use ${server.name}', + SavedServerAction.use => + primaryContext + ? 'Use ${server.name} for pipelines and runs' + : 'Use ${server.name}', SavedServerAction.edit => 'Edit ${server.name}', SavedServerAction.remove => 'Remove ${server.name}', }; List get _actions => [ - if (!selected) SavedServerAction.use, + if (allowSelection && !selected) SavedServerAction.use, SavedServerAction.edit, SavedServerAction.remove, ]; @@ -87,7 +93,9 @@ class SavedServerRow extends StatelessWidget { PopupMenuItem(value: action, child: Text(_label(action))), ], ); - final Widget mark = selected + final Widget mark = !allowSelection + ? Icon(cupertino ? CupertinoIcons.desktopcomputer : Icons.computer) + : selected ? Icon( cupertino ? CupertinoIcons.checkmark_circle_fill @@ -109,13 +117,18 @@ class SavedServerRow extends StatelessWidget { subtitle: Column( crossAxisAlignment: CrossAxisAlignment.start, children: [ - if (selected) const Text('Selected server'), + if (selected) + Text( + primaryContext ? 'Pipelines and runs server' : 'Selected server', + ), for (final (index, address) in server.endpoints.indexed) Text('${index == 0 ? 'Preferred' : 'Backup $index'}: $address'), ], ), trailing: menu, - onTap: selected || busy ? null : () => onAction(SavedServerAction.use), + onTap: !allowSelection || selected || busy + ? null + : () => onAction(SavedServerAction.use), ); } } diff --git a/app/lib/features/settings/saved_servers_section.dart b/app/lib/features/settings/saved_servers_section.dart index 26767aff..bd265fbb 100644 --- a/app/lib/features/settings/saved_servers_section.dart +++ b/app/lib/features/settings/saved_servers_section.dart @@ -1,6 +1,7 @@ import 'dart:async'; import 'package:flutter/cupertino.dart'; +import 'package:flutter/foundation.dart'; import 'package:flutter/material.dart'; import '../../core/servers/server_catalog.dart'; @@ -21,7 +22,12 @@ class _ServerSaveFailure implements Exception { } class SavedServersSection extends StatelessWidget { - const SavedServersSection({super.key, required this.connections}); + const SavedServersSection({ + super.key, + required this.connections, + this.allowPrimarySelection, + }); + final bool? allowPrimarySelection; final ServerConnections connections; Future _edit(BuildContext context, [SavedServer? server]) async { @@ -100,17 +106,27 @@ class SavedServersSection extends StatelessWidget { builder: (context, _) { final cupertino = usesCupertinoHost(context); final error = connections.error; + final allowSelection = allowPrimarySelection ?? !kIsWeb; return SettingsGroup( title: 'Servers', leadingRows: true, - footer: error == null - ? null - : Text(error, style: TextStyle(color: settingsErrorColor(context))), + footer: Column( + crossAxisAlignment: CrossAxisAlignment.start, + children: [ + const Text('All saved machines connect for chat.'), + if (allowSelection) + const Text('The primary machine is used for pipelines and runs.'), + if (error != null) + Text(error, style: TextStyle(color: settingsErrorColor(context))), + ], + ), children: [ for (final server in connections.catalog.servers) SavedServerRow( server: server, selected: server.id == connections.catalog.active?.id, + allowSelection: allowSelection, + primaryContext: true, busy: connections.busy, onAction: (act) => _act(context, server, act), ), diff --git a/app/notes/browser-network-discovery.md b/app/notes/browser-network-discovery.md index 6a2f84e4..6c6814c0 100644 --- a/app/notes/browser-network-discovery.md +++ b/app/notes/browser-network-discovery.md @@ -18,3 +18,9 @@ and native discovery regressions. Analyzer clean (NWAPbG), full-app fixture buil results and editable selected name/address fit. The fixture served controlled JSON at /api/discovery; actual backend auth/discovery has separate Node/Go tests. No production deployment or device testing in this commit. + +Saved browser server rows no longer offer an exclusive Use action or navigate on +tap. All saved machines connect for chat; primary selection is explicitly for +pipelines/runs on native hosts. A widget regression covers preservation of the +browser's current server identity when another saved machine is tapped. Combined +discovery/settings layout suite: 43 tests passed (out.c7dJ7j). diff --git a/app/test/features/settings/saved_server_discovery_test.dart b/app/test/features/settings/saved_server_discovery_test.dart index 96797829..dedeae7f 100644 --- a/app/test/features/settings/saved_server_discovery_test.dart +++ b/app/test/features/settings/saved_server_discovery_test.dart @@ -2,6 +2,10 @@ import 'dart:convert'; import 'package:flutter/material.dart'; import 'package:flutter_test/flutter_test.dart'; import 'package:pipelines_app/core/servers/server_catalog.dart'; +import 'package:pipelines_app/core/servers/server_catalog_store.dart'; +import 'package:pipelines_app/features/settings/server_connections.dart'; +import 'package:pipelines_app/features/settings/saved_servers_section.dart'; +import 'package:pipelines_app/features/settings/saved_server_row.dart'; import 'package:pipelines_app/features/settings/saved_server_editor.dart'; import 'package:pipelines_app/features/onboarding/discovery/browser_server_discovery.dart'; import 'package:pipelines_app/features/onboarding/onboarding_flow.dart'; @@ -20,6 +24,49 @@ BrowserServerDiscovery discovery() => BrowserServerDiscovery( ); void main() { + testWidgets( + 'browser server rows cannot navigate away by selecting one machine', + (tester) async { + final home = SavedServer.validated( + id: 'home', + name: 'Home', + endpoints: ['wss://home.test/connect'], + ); + final other = SavedServer.validated( + id: 'other', + name: 'Other', + endpoints: ['wss://other.test/connect'], + ); + final connections = ServerConnections( + store: MemoryServerCatalogStore( + catalog: ServerCatalog(servers: [home, other], selectedId: home.id), + ), + onSelected: (_) async => + fail('Browser must keep all chat connections in this page'), + ); + addTearDown(connections.dispose); + await connections.load(); + await tester.pumpWidget( + MaterialApp( + home: Scaffold( + body: SavedServersSection( + connections: connections, + allowPrimarySelection: false, + ), + ), + ), + ); + await tester.tap(find.text('Other')); + await tester.pumpAndSettle(); + expect(connections.catalog.active!.id, 'home'); + await tester.tap(find.byKey(savedServerMenuKey('other'))); + await tester.pumpAndSettle(); + expect(find.textContaining('Use Other'), findsNothing); + expect(find.text('Edit Other'), findsOneWidget); + expect(find.text('Remove Other'), findsOneWidget); + }, + ); + testWidgets( 'choosing a discovered machine prefills editable name and address', (tester) async { diff --git a/app/test/features/settings/settings_layout_test.dart b/app/test/features/settings/settings_layout_test.dart index 86e15a19..33b2bbe8 100644 --- a/app/test/features/settings/settings_layout_test.dart +++ b/app/test/features/settings/settings_layout_test.dart @@ -181,7 +181,7 @@ void main() { ); expect(find.byType(SavedServerRow), findsNWidgets(2)); - expect(find.text('Selected server'), findsOneWidget); + expect(find.text('Pipelines and runs server'), findsOneWidget); expect( find.byWidgetPredicate( (widget) => widget is Icon && widget.semanticLabel == 'Selected',