summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--README.md4
-rw-r--r--build.zig5
-rw-r--r--docs/9web.service18
-rw-r--r--docs/catalog.example.json13
-rw-r--r--docs/catalog.md177
-rw-r--r--test/web/catalog.py217
-rw-r--r--web/catalog.zig549
-rw-r--r--web/discover.py93
-rw-r--r--web/main.zig196
-rw-r--r--web/static/catalog.html14
-rw-r--r--web/static/catalog.js56
11 files changed, 1339 insertions, 3 deletions
diff --git a/README.md b/README.md
index 73efa3e..4aa4887 100644
--- a/README.md
+++ b/README.md
@@ -1,5 +1,9 @@
# cloud9
+`9web` also has a [local site catalogue](docs/catalog.md): serve generated
+websites directly, trigger or watch builds over HTTP/9P, and discover local HTTP
+listeners from process metadata without probing endpoints.
+
A Zig 0.17 library for base **9P2000** clients, servers, and transports.
The protocol core uses caller-owned buffers and bounded request tables. It has
diff --git a/build.zig b/build.zig
index 17080b4..a901201 100644
--- a/build.zig
+++ b/build.zig
@@ -40,6 +40,11 @@ pub fn build(b: *std.Build) void {
}) });
bridge.root_module.addAnonymousImport("client.wasm", .{ .root_source_file = wasm.getEmittedBin() });
b.installArtifact(bridge);
+ if (target.result.os.tag == .linux) {
+ const catalog_test = b.addSystemCommand(&.{ "python3", "test/web/catalog.py" });
+ catalog_test.addArtifactArg(bridge);
+ b.step("catalog-test", "Test local sites, controls, watcher and passive discovery").dependOn(&catalog_test.step);
+ }
const run_bridge = b.addRunArtifact(bridge);
run_bridge.addPassthruArgs();
b.step("serve", "Run the HTTP/WebSocket bridge (--upstream tcp:127.0.0.1:564)").dependOn(&run_bridge.step);
diff --git a/docs/9web.service b/docs/9web.service
new file mode 100644
index 0000000..a20bd89
--- /dev/null
+++ b/docs/9web.service
@@ -0,0 +1,18 @@
+[Unit]
+Description=9web local sites, build controls and listener catalogue
+After=network.target
+
+[Service]
+ExecStart=%h/.local/libexec/9web --listen [::]:8090 --catalog %h/.config/9web/sites.json --catalog-socket %t/9web/catalog.sock --state-dir %h/.local/state/9web
+Restart=on-failure
+RestartSec=2
+RuntimeDirectory=9web
+RuntimeDirectoryMode=0700
+UMask=0077
+KillMode=control-group
+TimeoutStopSec=10
+NoNewPrivileges=yes
+Environment=PATH=%h/.local/bin:/usr/local/bin:/usr/bin:/bin
+
+[Install]
+WantedBy=default.target
diff --git a/docs/catalog.example.json b/docs/catalog.example.json
new file mode 100644
index 0000000..c5970f3
--- /dev/null
+++ b/docs/catalog.example.json
@@ -0,0 +1,13 @@
+{
+ "sites": [
+ {
+ "name": "notes",
+ "title": "My notes",
+ "cwd": "/home/me/notes",
+ "root": "/home/me/notes/site/out",
+ "port": 8091,
+ "build": ["just", "site"],
+ "inputs": ["index.typ", "lib", "notes", "site/build.py", "site/site.css"]
+ }
+ ]
+}
diff --git a/docs/catalog.md b/docs/catalog.md
new file mode 100644
index 0000000..cd6eec9
--- /dev/null
+++ b/docs/catalog.md
@@ -0,0 +1,177 @@
+# 9web local catalogue (Linux)
+
+`9web --catalog FILE` runs a local website catalogue in the gateway process.
+It serves existing generated websites immediately, supervises requested builds,
+and inventories listening TCP sockets without making requests to them. No
+separate site servers are needed. The existing `--upstream` gateway mode is
+unchanged; catalogue mode and an explicit upstream are mutually exclusive.
+
+## Configuration and serving
+
+See [catalog.example.json](catalog.example.json). Every site has a unique `name`,
+`title`, absolute `cwd` and `root`, and a distinct nonzero HTTP `port`. Optional
+`build` and `watch` values are argument arrays, not shell command strings.
+Use an explicit `sh -c` only when a trusted recipe needs shell syntax.
+
+```
+9web --listen '[::]:8090' \
+ --catalog "$HOME/.config/9web/sites.json" \
+ --catalog-socket "$XDG_RUNTIME_DIR/9web/catalog.sock" \
+ --state-dir "$HOME/.local/state/9web"
+```
+
+Create the socket's parent directory first. Configuration is read at startup;
+restart the service to change it. A failed site-port bind fails startup rather
+than advertising a site that is not actually served. All site listeners use
+the dashboard's bind address. `[::]` uses a dual-stack listener for all IPv6 and
+IPv4 interfaces; `0.0.0.0` restricts this to IPv4.
+
+Each site occupies its own HTTP origin so root-relative `/assets/` and `/blog/`
+URLs work without HTML rewriting. Directory URLs redirect to a trailing slash
+and serve `index.html`; extensionless paths try `.html`. Static serving supports
+MIME types, HEAD, single byte ranges, and streaming large files. Symlink traversal,
+dotfiles, `..`, and encoded path separators are refused. Directory listings are
+available through 9P, not through site HTTP roots.
+
+The HTTP site root is static: provider-specific `_redirects`, `_headers`, and
+Worker APIs are not executed. For example the café's articles and assets work,
+but its Cloudflare poke API is not reproduced locally.
+
+## Builds and watch
+
+The dashboard has Build, Watch, Cancel, and Log controls. Builds execute in the
+configured working directory with the service's environment. One child job runs
+per site. Repeated build requests during a build coalesce into one later build.
+Build writes enqueue work immediately; serving does not wait for compilation.
+
+For managed watch, configure `inputs` as source paths relative to `cwd` (or absolute
+paths for shared libraries outside the project). The
+watcher checks source names, modification times and sizes once per second and
+invokes the build recipe on changes. It skips hidden entries, symlinks and common
+generated directories (`out`, `dist`, `build`, `node_modules`, `__pycache__`).
+List a particular build script explicitly if it lives in one of those directories.
+This is a metadata watcher, not a content hash or a Typst dependency graph.
+Changes during a build are detected by the next scan. Browser refresh is manual.
+
+Alternatively, `watch` can specify an existing persistent watcher. Its stdout and
+stderr go to the same log, and watch-off cancels its process group. A native watcher
+may itself serve a preview port, but the catalogue never requires that preview to
+serve the site's generated files. Manual builds are refused while a native watcher
+is active. Cancel disables watching and clears queued work. Server shutdown under
+systemd kills the whole service cgroup, including build descendants.
+
+Each new job replaces `<state-dir>/<name>.log`. The UI and 9P expose its last
+256 KiB; the on-disk log is not rotated during a long-running native watcher.
+Watch state and build status reset at service restart; generated output remains.
+No build or watch is started automatically.
+
+Builders currently write to their configured output directories in place.
+`9web` does **not** provide atomic publication or a last-good snapshot: a failed
+build can leave partial output, and a file truncated during a response closes that
+response. Builders needing atomic publication should generate a separate release
+directory and arrange publication themselves. The served root can be a symlink;
+symlinks below that root are refused.
+
+## 9P and HTTP controls
+
+The catalogue is itself a 9P backend, consumed by the ordinary gateway mux.
+`--serve` and WebSocket clients see the same tree as direct socket clients:
+
+```
+/index.html
+/sites/<name>/public/ complete generated output tree (read-only)
+/sites/<name>/ctl build | watch on | watch off | cancel
+/sites/<name>/status JSON state, PID, exit code, times, generation
+/sites/<name>/log last 256 KiB of current/most recent job
+/sites/<name>/events blocking stream of JSON state changes
+/services/index.json recognized HTTP/HTTPS listeners
+/listeners/index.json all observed TCP listeners, including unknown ones
+```
+
+```
+9ns --unix "$XDG_RUNTIME_DIR/9web/catalog.sock" --name web -- sh
+echo build > /mnt/9p/web/sites/entomology/ctl
+cat /mnt/9p/web/sites/entomology/status
+cat /mnt/9p/web/sites/entomology/log
+```
+
+Event opens receive the current state, then park until its revision changes.
+Each reader has its own cursor; slow readers receive the newest state, not a
+durable history of every transition. 9P flush cancels parked reads. State events
+also work through `/fs/sites/<name>/events?follow=1` as SSE. `status` is the finite
+snapshot to use for ordinary polling.
+
+The dashboard reads `GET /_cloud9/catalog.json` and uses
+`POST /_cloud9/sites/<name>/ctl` with a plain-text command. The existing
+`PUT /fs/sites/<name>/ctl` also reaches the same control implementation.
+
+## Passive discovery
+
+Every five seconds, an embedded Python 3 inventory helper reads `/proc/net/tcp*`,
+joins socket inodes to process descriptors, and recognizes executable/argument
+patterns for miniserve, Python `http.server`, Typst watch, Vite and Wrangler dev.
+9web advertises only its explicitly registered HTTP ports: its 9P listener is
+never labelled HTTP just because the owning executable is 9web.
+
+No TCP connections or HTTP probes are performed. Unknown or inaccessible process
+ownership stays unknown. Full command lines and environments are not published;
+entries contain address, actual bound port, PID, executable, cwd and the evidence
+for classification. Process races and permissions can make entries temporarily
+unknown. Discovery is in the service's network namespace, not across containers.
+The helper is a short-lived child of 9web, not another daemon.
+
+Wildcard addresses in dashboard links use the browser's current server hostname.
+Specific addresses remain specific; loopback services are labelled local-only.
+There is no automatic proxy to loopback-only services. Recognizers identify likely
+HTTP listeners from process evidence; they cannot prove application health.
+
+## Service and access
+
+[9web.service](9web.service) is a user-systemd unit template. Install the binary
+at `~/.local/libexec/9web`, the config at `~/.config/9web/sites.json`, and the unit
+at `~/.config/systemd/user/9web.service`, then:
+
+```
+systemctl --user daemon-reload
+systemctl --user enable --now 9web.service
+systemctl --user status 9web.service
+journalctl --user -u 9web.service
+```
+
+The unit supplies a private runtime directory and socket, restarts on failure,
+and kills child jobs together with the service. Lingering must be enabled if the
+user service should run without an interactive login. It needs `python3`, `setsid`,
+and the configured project build tools in PATH. Miniserve remains independent.
+
+This is a trusted-network operator interface: it has **no login or TLS**. Anyone
+who can reach the dashboard can read the catalogue and trigger configured jobs.
+Browser control requests reject foreign Origins; numeric Host validation and
+separate site origins prevent served pages from using the dashboard as a same-origin
+control API. This is not authentication. Bind to loopback or place an authenticated
+gateway in front of it when those network permissions are inappropriate. No
+arbitrary command can be supplied through HTTP or 9P; commands come from the local
+registry, which should remain writable only by its owner.
+
+## Verification
+
+```
+zig build catalog-test http-fs-test mux-test -Doptimize=ReleaseSafe
+```
+
+The catalogue integration test uses temporary real sites and processes. It checks
+immediate static serving, pretty URLs, MIME, HEAD/ranges, traversal and symlink
+rejection, Host/Origin checks, HTTP and raw 9P controls, watched rebuilds, failed
+build status, process-group cancellation, nonblocking event readers, and actual
+socket ownership discovery. Existing gateway HTTP/filesystem and mux suites cover
+the original mode.
+
+## Installed workstation configuration
+
+The initial workstation setup uses dashboard port 8090 and site ports 8091–8095:
+Entomology lab, 0x4200.cafe, Standards, Pardes website, and the older café hub archive.
+The archive is read-only (no build recipe registered). Other sites have explicit
+local build recipes and opt-in managed watches. Port 8081 remains miniserve's.
+Runtime config is `~/.config/9web/sites.json`; the service uses a separately
+installed binary so subsequent development builds do not change the running
+service's executable on disk. Source and deployment changes are described in
+the implementing git commit; no remote push is required for the local service.
diff --git a/test/web/catalog.py b/test/web/catalog.py
new file mode 100644
index 0000000..e1b153e
--- /dev/null
+++ b/test/web/catalog.py
@@ -0,0 +1,217 @@
+#!/usr/bin/env python3
+"""Black-box catalogue checks: real HTTP, 9P, child processes and files."""
+from http.client import HTTPConnection, HTTPException
+import importlib.util
+import json
+import os
+from pathlib import Path
+import socket
+import struct
+import subprocess
+import sys
+import tempfile
+import time
+
+
+def port():
+ with socket.socket() as s:
+ s.bind(('127.0.0.1', 0))
+ return s.getsockname()[1]
+
+
+def eventually(f, timeout=15):
+ end = time.monotonic() + timeout
+ while time.monotonic() < end:
+ try:
+ value = f()
+ if value:
+ return value
+ except (OSError, HTTPException):
+ pass
+ time.sleep(.1)
+ raise AssertionError('timed out: ' + repr(f))
+
+
+def http(p, path='/', method='GET', body=None, headers=None):
+ c = HTTPConnection('127.0.0.1', p, timeout=5)
+ try:
+ c.request(method, path, body, headers or {})
+ r = c.getresponse()
+ return r.status, dict(r.getheaders()), r.read()
+ finally:
+ c.close()
+
+
+def string(s):
+ b = s.encode()
+ return struct.pack('<H', len(b)) + b
+
+
+class Nine:
+ def __init__(self, path):
+ self.s = socket.socket(socket.AF_UNIX)
+ self.s.settimeout(5)
+ self.s.connect(path)
+ self.rpc(100, struct.pack('<I', 65536) + string('9P2000'), 65535)
+ self.rpc(104, struct.pack('<II', 1, 0xffffffff) + string('user') + string(''))
+
+ def recv(self, n):
+ b = b''
+ while len(b) < n:
+ chunk = self.s.recv(n-len(b))
+ if not chunk:
+ raise AssertionError('9P disconnected')
+ b += chunk
+ return b
+
+ def rpc(self, t, body, tag=1):
+ self.s.sendall(struct.pack('<IBH', len(body)+7, t, tag) + body)
+ size, rt, rtag = struct.unpack('<IBH', self.recv(7))
+ result = self.recv(size-7)
+ assert rt != 107, result
+ assert rt == t+1 and rtag == tag, (rt, rtag)
+ return result
+
+ def walk(self, path):
+ names = path.split('/')
+ r = self.rpc(110, struct.pack('<IIH', 1, 2, len(names)) + b''.join(map(string, names)))
+ assert struct.unpack('<H', r[:2])[0] == len(names), path
+
+ def read(self, path):
+ self.walk(path)
+ self.rpc(112, struct.pack('<IB', 2, 0))
+ r = self.rpc(116, struct.pack('<IQI', 2, 0, 32000))
+ self.rpc(120, struct.pack('<I', 2))
+ return r[4:]
+
+ def write(self, path, text):
+ self.walk(path)
+ self.rpc(112, struct.pack('<IB', 2, 0x11))
+ b = text.encode()
+ self.rpc(118, struct.pack('<IQI', 2, 0, len(b)) + b)
+ self.rpc(120, struct.pack('<I', 2))
+
+ def list(self, path):
+ self.walk(path)
+ self.rpc(112, struct.pack('<IB', 2, 0))
+ offset, names = 0, []
+ while True:
+ data = self.rpc(116, struct.pack('<IQI', 2, offset, 160))[4:]
+ if not data: break
+ offset += len(data)
+ while data:
+ size = struct.unpack('<H', data[:2])[0] + 2
+ nlen = struct.unpack('<H', data[41:43])[0]
+ names.append(data[43:43+nlen].decode())
+ data = data[size:]
+ self.rpc(120, struct.pack('<I', 2))
+ return names
+
+
+def main():
+ binary = str(Path(sys.argv[1] if len(sys.argv) > 1 else 'zig-out/bin/9web').resolve())
+ spec = importlib.util.spec_from_file_location('discover', Path(__file__).resolve().parents[2] / 'web/discover.py')
+ discover = importlib.util.module_from_spec(spec)
+ spec.loader.exec_module(discover)
+ assert discover.recognize(['python3', '-m', 'http.server', '8000'])
+ assert discover.recognize(['node', '/project/app.js', 'vite']) is None
+ assert discover.recognize(['miniserve', '--tls-cert', 'cert'])[1] == 'https'
+ with tempfile.TemporaryDirectory(prefix='9web-catalog-') as tmp:
+ root = Path(tmp)
+ public = root/'public'
+ public.mkdir()
+ (public/'index.html').write_text('<h1>catalog fixture</h1>')
+ (public/'style.css').write_text('body{color:red}')
+ (public/'pretty.html').write_text('pretty page')
+ (public/'nested').mkdir()
+ (public/'nested/index.html').write_text('nested page')
+ (root/'secret').write_text('must not serve')
+ (public/'escape').symlink_to(root/'secret')
+ (public/'escape-dir').symlink_to(root, target_is_directory=True)
+ (root/'source.txt').write_text('source')
+ dashboard, site_port, python_port = port(), port(), port()
+ cfg = dict(sites=[dict(name='fixture', title='Fixture', cwd=tmp, root=str(public), port=site_port,
+ build=['sh','-c','echo build-output; if test -f slow; then sleep 30 & echo $! > descendant; wait; fi; sleep 0.2; cp source.txt public/result.txt'], inputs=['source.txt'])])
+ (root/'catalog.json').write_text(json.dumps(cfg))
+ log = open(root/'server.log', 'wb')
+ proc = subprocess.Popen([binary, '--listen', f'0.0.0.0:{dashboard}', '--catalog', str(root/'catalog.json'), '--catalog-socket', str(root/'catalog.sock'), '--state-dir', str(root/'state')], stdout=log, stderr=log)
+ py = subprocess.Popen([sys.executable, '-m', 'http.server', str(python_port), '--bind', '127.0.0.1', '--directory', str(public)], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+ try:
+ eventually(lambda: http(dashboard)[0] == 200)
+ assert http(site_port)[2] == b'<h1>catalog fixture</h1>'
+ assert http(site_port, '/style.css')[1]['content-type'] == 'text/css'
+ assert http(site_port, '/pretty')[2] == b'pretty page'
+ assert http(site_port, '/nested')[0] == 301
+ assert http(site_port, '/nested/')[2] == b'nested page'
+ assert http(site_port, '/', 'HEAD')[2] == b''
+ assert http(site_port, '/style.css', headers={'Range':'bytes=0-3'})[2] == b'body'
+ for path in ['/../secret', '/%2e%2e/secret', '/escape', '/escape-dir/secret', '/.git/config', '/%2fetc/passwd']:
+ assert http(site_port, path)[0] in (400,403,404), path
+ assert http(dashboard, headers={'Host':'attacker.invalid'})[0] == 403
+ ctl = '/_cloud9/sites/fixture/ctl'
+ assert http(dashboard, ctl, 'POST', 'build', {'Origin':'https://attacker.invalid'})[0] == 403
+ assert http(dashboard, ctl, 'POST', 'bogus')[0] == 400
+ nine = Nine(str(root/'catalog.sock'))
+ assert nine.list('sites') == ['fixture']
+ assert nine.list('sites/fixture') == ['ctl', 'events', 'log', 'public', 'status']
+ assert nine.list('sites/fixture/public') == ['index.html', 'nested', 'pretty.html', 'style.css']
+ assert nine.read('sites/fixture/public/index.html').startswith(b'<h1>')
+ assert b'build' in nine.read('sites/fixture/ctl')
+ nine.write('sites/fixture/ctl', 'build\n')
+ eventually(lambda: (public/'result.txt').exists())
+ eventually(lambda: json.loads(nine.read('sites/fixture/status'))['generation'] == 1)
+ assert b'build-output' in nine.read('sites/fixture/log')
+ assert http(dashboard, ctl, 'POST', 'watch on')[0] == 202
+ eventually(lambda: json.loads(nine.read('sites/fixture/status'))['generation'] >= 2)
+ (root/'source.txt').write_text('changed source')
+ eventually(lambda: (public/'result.txt').read_text() == 'changed source')
+ assert http(dashboard, ctl, 'POST', 'watch off')[0] == 202
+ def discovered():
+ data = json.loads(http(dashboard, '/_cloud9/catalog.json')[2])
+ return any(x['port'] == python_port and x['service'] == 'python http.server' for x in data['listeners'])
+ eventually(discovered)
+ # A parked event reader must not stall HTTP or other 9P clients.
+ events = Nine(str(root/'catalog.sock'))
+ events.walk('sites/fixture/events')
+ events.rpc(112, struct.pack('<IB', 2, 0))
+ first = events.rpc(116, struct.pack('<IQI', 2, 0, 2048))
+ assert json.loads(first[4:])['revision'] > 0
+ pending = struct.pack('<IQI', 2, len(first)-4, 2048)
+ events.s.sendall(struct.pack('<IBH', len(pending)+7, 116, 2) + pending)
+ assert http(site_port)[0] == 200
+ (root/'slow').write_text('yes')
+ nine.write('sites/fixture/ctl', 'build')
+ size, typ, tag = struct.unpack('<IBH', events.recv(7))
+ assert (typ, tag) == (117, 2)
+ assert json.loads(events.recv(size-7)[4:])['revision'] > json.loads(first[4:])['revision']
+ eventually(lambda: (root/'descendant').exists())
+ nine.write('sites/fixture/ctl', 'cancel')
+ eventually(lambda: json.loads(nine.read('sites/fixture/status'))['phase'] == 'canceled')
+ descendant = int((root/'descendant').read_text())
+ def stopped():
+ try: return Path(f'/proc/{descendant}/stat').read_text().split(') ')[1].startswith('Z')
+ except FileNotFoundError: return True
+ eventually(stopped)
+ events.s.close()
+ (root/'slow').unlink()
+ # A failed compile leaves readable existing output and reports failure.
+ (root/'source.txt').unlink()
+ nine.write('sites/fixture/ctl', 'build')
+ eventually(lambda: json.loads(nine.read('sites/fixture/status'))['phase'] == 'failed')
+ assert http(site_port)[0] == 200
+ nine.s.close()
+ print('catalog: HTTP serving, paths, MIME, HEAD/range, controls, watch, failure, cancellation, 9P events and passive discovery passed')
+ except BaseException:
+ log.flush()
+ print((root/'server.log').read_text(), file=sys.stderr)
+ raise
+ finally:
+ proc.terminate(); py.terminate()
+ for p in (proc, py):
+ try: p.wait(timeout=5)
+ except subprocess.TimeoutExpired: p.kill(); p.wait()
+ log.close()
+
+
+if __name__ == '__main__':
+ main()
diff --git a/web/catalog.zig b/web/catalog.zig
new file mode 100644
index 0000000..5e75555
--- /dev/null
+++ b/web/catalog.zig
@@ -0,0 +1,549 @@
+//! Local sites, build supervision and passive listener discovery. All state is
+//! owned by 9web; HTTP and 9P use the same controls. Linux catalogue mode only.
+const std = @import("std");
+const c9 = @import("cloud9");
+const Io = std.Io;
+const A = std.heap.page_allocator;
+const fs = c9.fs;
+const Backend = struct {
+ pub const Req = fs.Req;
+ pub const Reply = fs.Reply;
+};
+pub const Runner = c9.serve.Runner(Backend, .{ .fid_capacity = 512, .name_capacity = 255 }, .{ .msize = 65536, .connections = 16 });
+
+pub const Site = struct {
+ name: []const u8,
+ title: []const u8,
+ cwd: []const u8,
+ root: []const u8,
+ port: u16,
+ build: []const []const u8 = &.{},
+ watch: []const []const u8 = &.{},
+ // Poll only these source paths for a managed rebuild watcher.
+ inputs: []const []const u8 = &.{},
+};
+const Settings = struct { sites: []const Site };
+const State = struct {
+ phase: []const u8 = "idle",
+ watching: bool = false,
+ queued: bool = false,
+ cancel: bool = false,
+ pid: ?i32 = null,
+ exit_code: ?u8 = null,
+ started: i64 = 0,
+ finished: i64 = 0,
+ generation: u64 = 0,
+ fingerprint: u64 = 0,
+ revision: u64 = 1,
+};
+const EventCursor = struct {
+ used: bool = false,
+ revision: u64 = 0,
+ bytes: [2048]u8 = undefined,
+ len: usize = 0,
+ pos: usize = 0,
+};
+pub const Catalog = struct {
+ io: Io,
+ sites: []const Site,
+ states: []State,
+ state_dir: []const u8,
+ mutex: Io.Mutex = .init,
+ nodes: std.ArrayList([]const u8) = .empty,
+ listeners: []const u8 = "[]",
+ discovery_error: []const u8 = "",
+ group: Io.Group = .init,
+ runner: *Runner,
+ http_port: u16 = 0,
+ cursors: [16][64]EventCursor = @splat(@splat(.{})),
+
+ pub fn init(io: Io, config: []const u8, state_dir: []const u8) !*Catalog {
+ const bytes = try Io.Dir.cwd().readFileAlloc(io, config, A, .limited(1024 * 1024));
+ defer A.free(bytes);
+ const parsed = try std.json.parseFromSlice(Settings, A, bytes, .{ .allocate = .alloc_always });
+ // Config is immutable for the lifetime of the process.
+ var names: std.StringHashMap(void) = .init(A);
+ defer names.deinit();
+ for (parsed.value.sites, 0..) |s, i| {
+ if (s.name.len == 0 or s.port == 0 or !std.fs.path.isAbsolute(s.root) or !std.fs.path.isAbsolute(s.cwd)) return error.InvalidSite;
+ for (s.name) |ch| if (!std.ascii.isAlphanumeric(ch) and ch != '-' and ch != '_') return error.InvalidSiteName;
+ if (names.contains(s.name)) return error.DuplicateSite;
+ try names.put(s.name, {});
+ for (parsed.value.sites[0..i]) |other| if (other.port == s.port) return error.DuplicatePort;
+ for (s.inputs) |input| if (!std.fs.path.isAbsolute(input) and !safeRelative(input)) return error.InvalidWatchInput;
+ }
+ try Io.Dir.cwd().createDirPath(io, state_dir);
+ const cat = try A.create(Catalog);
+ cat.* = .{ .io = io, .sites = parsed.value.sites, .states = try A.alloc(State, parsed.value.sites.len), .state_dir = state_dir, .runner = try A.create(Runner) };
+ @memset(cat.states, .{});
+ try cat.nodes.append(A, "");
+ cat.runner.init(.{ .io = io, .root = 1, .handler = .{ .ctx = cat, .serve = serve } });
+ return cat;
+ }
+
+ pub fn start(cat: *Catalog, socket: [:0]const u8) !void {
+ _ = try cat.runner.listen(.{ .unix = socket }, 16);
+ try cat.group.concurrent(cat.io, discoverLoop, .{cat});
+ for (cat.sites, 0..) |_, i| try cat.group.concurrent(cat.io, siteLoop, .{ cat, i });
+ }
+
+ pub fn stop(cat: *Catalog) void {
+ cat.group.cancel(cat.io);
+ cat.runner.stop();
+ }
+
+ fn now(cat: *Catalog) i64 {
+ return Io.Timestamp.now(cat.io, .real).toSeconds();
+ }
+ fn logPath(cat: *Catalog, a: std.mem.Allocator, i: usize) ![]const u8 {
+ return std.fmt.allocPrint(a, "{s}/{s}.log", .{ cat.state_dir, cat.sites[i].name });
+ }
+ pub fn control(cat: *Catalog, i: usize, command: []const u8) !void {
+ cat.mutex.lockUncancelable(cat.io);
+ defer cat.mutex.unlock(cat.io);
+ const cmd = std.mem.trim(u8, command, " \r\n\t");
+ const s = &cat.states[i];
+ if (std.mem.eql(u8, cmd, "build")) {
+ if (cat.sites[i].build.len == 0) return error.NoBuildCommand;
+ if (s.watching and cat.sites[i].watch.len != 0) return error.NativeWatcherRunning;
+ s.queued = true;
+ } else if (std.mem.eql(u8, cmd, "watch on")) {
+ if (cat.sites[i].watch.len == 0 and (cat.sites[i].inputs.len == 0 or cat.sites[i].build.len == 0)) return error.NoWatchInputs;
+ s.watching = true;
+ s.queued = true;
+ } else if (std.mem.eql(u8, cmd, "watch off")) {
+ s.watching = false;
+ if (cat.sites[i].watch.len != 0) s.cancel = true;
+ } else if (std.mem.eql(u8, cmd, "cancel")) {
+ s.watching = false;
+ s.queued = false;
+ s.cancel = true;
+ } else return error.UnknownControl;
+ s.revision += 1;
+ cat.runner.wakeAll();
+ }
+
+ pub fn snapshot(cat: *Catalog, a: std.mem.Allocator) ![]const u8 {
+ cat.mutex.lockUncancelable(cat.io);
+ defer cat.mutex.unlock(cat.io);
+ const Row = struct { name: []const u8, title: []const u8, root: []const u8, port: u16, build: bool, watch: bool, status: State };
+ const rows = try a.alloc(Row, cat.sites.len);
+ for (cat.sites, 0..) |s, i| rows[i] = .{ .name = s.name, .title = s.title, .root = s.root, .port = s.port, .build = s.build.len != 0, .watch = s.watch.len != 0 or s.inputs.len != 0, .status = cat.states[i] };
+ const listeners = try std.json.parseFromSlice(std.json.Value, a, cat.listeners, .{});
+ return std.json.Stringify.valueAlloc(a, .{ .sites = rows, .listeners = listeners.value, .discovery_error = cat.discovery_error }, .{});
+ }
+
+ fn discoverLoop(cat: *Catalog) void {
+ while (true) {
+ var arena = std.heap.ArenaAllocator.init(A);
+ defer arena.deinit();
+ const a = arena.allocator();
+ const pid = std.fmt.allocPrint(a, "{d}", .{std.os.linux.getpid()}) catch return;
+ var ports: std.Io.Writer.Allocating = .init(a);
+ ports.writer.print("{d}", .{cat.http_port}) catch return;
+ for (cat.sites) |site| ports.writer.print(",{d}", .{site.port}) catch return;
+ const result = std.process.run(A, cat.io, .{ .argv = &.{ "python3", "-c", @embedFile("discover.py"), pid, ports.written() }, .stdout_limit = .limited(2 * 1024 * 1024), .stderr_limit = .limited(8192), .timeout = .{ .duration = .{ .raw = .fromSeconds(15), .clock = .awake } } }) catch |err| {
+ if (err == error.Canceled) return;
+ cat.mutex.lockUncancelable(cat.io);
+ cat.discovery_error = @errorName(err);
+ cat.mutex.unlock(cat.io);
+ cat.io.sleep(.fromSeconds(5), .awake) catch return;
+ continue;
+ };
+ defer A.free(result.stderr);
+ cat.mutex.lockUncancelable(cat.io);
+ if (result.term == .exited and result.term.exited == 0) {
+ if (cat.listeners.len > 2) A.free(cat.listeners);
+ cat.listeners = result.stdout;
+ cat.discovery_error = "";
+ } else {
+ A.free(result.stdout);
+ cat.discovery_error = "listener inventory failed";
+ }
+ cat.mutex.unlock(cat.io);
+ cat.io.sleep(.fromSeconds(5), .awake) catch return;
+ }
+ }
+
+ fn fingerprint(cat: *Catalog, i: usize) u64 {
+ var hash = std.hash.Wyhash.init(0);
+ var arena = std.heap.ArenaAllocator.init(A);
+ defer arena.deinit();
+ const a = arena.allocator();
+ for (cat.sites[i].inputs) |input| {
+ const path = if (std.fs.path.isAbsolute(input)) input else std.fs.path.join(a, &.{ cat.sites[i].cwd, input }) catch continue;
+ const st = Io.Dir.cwd().statFile(cat.io, path, .{ .follow_symlinks = false }) catch continue;
+ hash.update(input);
+ if (st.kind != .directory) {
+ hash.update(std.mem.asBytes(&st.mtime));
+ hash.update(std.mem.asBytes(&st.size));
+ continue;
+ }
+ var dir = Io.Dir.cwd().openDir(cat.io, path, .{ .iterate = true, .follow_symlinks = false }) catch continue;
+ defer dir.close(cat.io);
+ var walker = dir.walkSelectively(a) catch continue;
+ defer walker.deinit();
+ // XOR entry hashes so directory iteration ordering does not trigger builds.
+ var tree: u64 = 0;
+ while (walker.next(cat.io) catch null) |entry| {
+ if (entry.basename[0] == '.' or std.mem.eql(u8, entry.basename, "node_modules") or std.mem.eql(u8, entry.basename, "out") or std.mem.eql(u8, entry.basename, "build") or std.mem.eql(u8, entry.basename, "dist") or std.mem.eql(u8, entry.basename, "__pycache__")) continue;
+ if (entry.kind == .directory) {
+ walker.enter(cat.io, entry) catch {};
+ continue;
+ }
+ if (entry.kind != .file) continue;
+ const es = entry.dir.statFile(cat.io, entry.basename, .{ .follow_symlinks = false }) catch continue;
+ var eh = std.hash.Wyhash.init(0);
+ eh.update(entry.path);
+ eh.update(std.mem.asBytes(&es.mtime));
+ eh.update(std.mem.asBytes(&es.size));
+ tree ^= eh.final();
+ }
+ hash.update(std.mem.asBytes(&tree));
+ }
+ return hash.final();
+ }
+
+ fn siteLoop(cat: *Catalog, i: usize) void {
+ while (true) {
+ cat.mutex.lockUncancelable(cat.io);
+ const scanning = cat.states[i].watching and cat.sites[i].watch.len == 0;
+ const previous = cat.states[i].fingerprint;
+ cat.mutex.unlock(cat.io);
+ const fp = if (scanning) cat.fingerprint(i) else previous;
+ cat.mutex.lockUncancelable(cat.io);
+ const s = &cat.states[i];
+ if (s.watching and cat.sites[i].watch.len == 0 and fp != s.fingerprint) s.queued = true;
+ s.fingerprint = fp;
+ const run = s.queued;
+ const native = s.watching and cat.sites[i].watch.len != 0;
+ if (run) {
+ s.queued = false;
+ s.cancel = false;
+ s.phase = if (native) "watching" else "building";
+ s.started = cat.now();
+ s.exit_code = null;
+ s.revision += 1;
+ cat.runner.wakeAll();
+ }
+ cat.mutex.unlock(cat.io);
+ if (run) cat.runBuild(i, native) catch |err| {
+ if (err == error.Canceled) return;
+ cat.mutex.lockUncancelable(cat.io);
+ cat.states[i].phase = @errorName(err);
+ cat.states[i].pid = null;
+ cat.states[i].finished = cat.now();
+ cat.states[i].revision += 1;
+ cat.runner.wakeAll();
+ cat.mutex.unlock(cat.io);
+ };
+ cat.io.sleep(.fromSeconds(1), .awake) catch return;
+ }
+ }
+
+ const Job = struct {
+ child: std.process.Child,
+ done: std.atomic.Value(bool) = .init(false),
+ term: ?std.process.Child.Term = null,
+ fn wait(job: *Job, io: Io) void {
+ job.term = job.child.wait(io) catch null;
+ job.done.store(true, .release);
+ }
+ };
+ fn runBuild(cat: *Catalog, i: usize, native: bool) !void {
+ const path = try cat.logPath(A, i);
+ defer A.free(path);
+ const log = try Io.Dir.cwd().createFile(cat.io, path, .{});
+ defer log.close(cat.io);
+ const cmd = if (native) cat.sites[i].watch else cat.sites[i].build;
+ const argv = try A.alloc([]const u8, cmd.len + 1);
+ defer A.free(argv);
+ argv[0] = "setsid";
+ @memcpy(argv[1..], cmd);
+ var job: Job = .{ .child = try std.process.spawn(cat.io, .{ .argv = argv, .cwd = .{ .path = cat.sites[i].cwd }, .stdin = .ignore, .stdout = .{ .file = log }, .stderr = .{ .file = log } }) };
+ const pid = job.child.id.?;
+ var group: Io.Group = .init;
+ // Cancel whole session, not just a shell, including on server shutdown.
+ defer {
+ _ = std.os.linux.kill(-pid, std.os.linux.SIG.KILL);
+ group.cancel(cat.io);
+ job.child.kill(cat.io);
+ }
+ cat.mutex.lockUncancelable(cat.io);
+ cat.states[i].pid = pid;
+ cat.mutex.unlock(cat.io);
+ try group.concurrent(cat.io, Job.wait, .{ &job, cat.io });
+ var canceled = false;
+ while (!job.done.load(.acquire)) {
+ cat.mutex.lockUncancelable(cat.io);
+ const cancel = cat.states[i].cancel;
+ cat.mutex.unlock(cat.io);
+ if (cancel) {
+ canceled = true;
+ _ = std.os.linux.kill(-pid, std.os.linux.SIG.KILL);
+ }
+ try cat.io.sleep(.fromMilliseconds(100), .awake);
+ }
+ cat.mutex.lockUncancelable(cat.io);
+ defer cat.mutex.unlock(cat.io);
+ const s = &cat.states[i];
+ const code: u8 = if (job.term) |term| (if (term == .exited) term.exited else 128) else 255;
+ s.pid = null;
+ s.exit_code = code;
+ s.finished = cat.now();
+ s.phase = if (canceled) "canceled" else if (code == 0) "idle" else "failed";
+ if (code == 0 and !canceled) s.generation += 1;
+ if (native) s.watching = false;
+ s.revision += 1;
+ cat.runner.wakeAll();
+ }
+
+ fn intern(cat: *Catalog, path: []const u8) !u64 {
+ for (cat.nodes.items, 0..) |n, i| if (std.mem.eql(u8, n, path)) return i + 1;
+ if (cat.nodes.items.len >= 65536) return error.TooManyPaths;
+ try cat.nodes.append(A, try A.dupe(u8, path));
+ return cat.nodes.items.len;
+ }
+ fn sitePath(cat: *Catalog, path: []const u8) ?struct { i: usize, rest: []const u8 } {
+ if (!std.mem.startsWith(u8, path, "sites/")) return null;
+ const rest = path[6..];
+ const n = std.mem.indexOfScalar(u8, rest, '/') orelse rest.len;
+ for (cat.sites, 0..) |s, i| if (std.mem.eql(u8, rest[0..n], s.name)) return .{ .i = i, .rest = if (n == rest.len) "" else rest[n + 1 ..] };
+ return null;
+ }
+ fn attr(cat: *Catalog, a: std.mem.Allocator, path: []const u8) !fs.Attr {
+ var result = try cat.attrData(a, path);
+ result.node = try cat.intern(path);
+ return result;
+ }
+ fn attrData(cat: *Catalog, a: std.mem.Allocator, path: []const u8) !fs.Attr {
+ var result: fs.Attr = .{ .name = std.fs.path.basename(path), .mode = 0o444 };
+ if (path.len == 0 or std.mem.eql(u8, path, "sites") or std.mem.eql(u8, path, "services") or std.mem.eql(u8, path, "listeners")) {
+ result.dir = true;
+ result.mode = 0o555;
+ return result;
+ }
+ if (cat.sitePath(path)) |p| {
+ if (p.rest.len == 0 or std.mem.eql(u8, p.rest, "public")) {
+ result.dir = true;
+ result.mode = 0o555;
+ return result;
+ }
+ if (std.mem.startsWith(u8, p.rest, "public/")) {
+ const file = try openBeneath(cat.io, cat.sites[p.i].root, p.rest[7..]);
+ defer file.close(cat.io);
+ const st = try file.stat(cat.io);
+ result.dir = st.kind == .directory;
+ result.mode = if (result.dir) 0o555 else 0o444;
+ result.size = st.size;
+ result.mtime = @intCast(@max(0, st.mtime.toSeconds()));
+ return result;
+ }
+ if (std.mem.eql(u8, p.rest, "ctl")) {
+ result.mode = 0o666;
+ return result;
+ }
+ }
+ const data = try cat.content(a, path);
+ result.size = data.len;
+ return result;
+ }
+ fn content(cat: *Catalog, a: std.mem.Allocator, path: []const u8) ![]const u8 {
+ if (std.mem.eql(u8, path, "index.html")) return @embedFile("static/catalog.html");
+ if (std.mem.eql(u8, path, "listeners/index.json")) return cat.listeners;
+ if (std.mem.eql(u8, path, "services/index.json")) {
+ const parsed = try std.json.parseFromSlice([]std.json.Value, a, cat.listeners, .{});
+ var known: std.ArrayList(std.json.Value) = .empty;
+ for (parsed.value) |v| if (!std.mem.eql(u8, v.object.get("protocol").?.string, "unknown")) {
+ try known.append(a, v);
+ };
+ return std.json.Stringify.valueAlloc(a, known.items, .{});
+ }
+ if (cat.sitePath(path)) |p| {
+ if (std.mem.eql(u8, p.rest, "status") or std.mem.eql(u8, p.rest, "events")) return std.json.Stringify.valueAlloc(a, cat.states[p.i], .{});
+ if (std.mem.eql(u8, p.rest, "ctl")) return "build\nwatch on\nwatch off\ncancel\n";
+ if (std.mem.eql(u8, p.rest, "log")) {
+ const f = Io.Dir.cwd().openFile(cat.io, try cat.logPath(a, p.i), .{}) catch return "";
+ defer f.close(cat.io);
+ const st = try f.stat(cat.io);
+ const n = @min(st.size, 256 * 1024);
+ const b = try a.alloc(u8, @intCast(n));
+ return b[0..try f.readPositionalAll(cat.io, b, st.size - n)];
+ }
+ }
+ return error.FileNotFound;
+ }
+ fn children(cat: *Catalog, a: std.mem.Allocator, path: []const u8) ![][]const u8 {
+ var names: std.ArrayList([]const u8) = .empty;
+ if (path.len == 0) try names.appendSlice(a, &.{ "index.html", "sites", "services", "listeners" }) else if (std.mem.eql(u8, path, "sites")) {
+ for (cat.sites) |s| try names.append(a, s.name);
+ } else if (std.mem.eql(u8, path, "services") or std.mem.eql(u8, path, "listeners")) try names.append(a, "index.json") else if (cat.sitePath(path)) |p| {
+ if (p.rest.len == 0) try names.appendSlice(a, &.{ "public", "ctl", "status", "log", "events" }) else if (std.mem.eql(u8, p.rest, "public") or std.mem.startsWith(u8, p.rest, "public/")) {
+ const rel = if (p.rest.len == 6) "" else p.rest[7..];
+ const f = try openBeneath(cat.io, cat.sites[p.i].root, rel);
+ defer f.close(cat.io);
+ var dir: Io.Dir = .{ .handle = f.handle };
+ var it = dir.iterate();
+ while (try it.next(cat.io)) |e| if (e.kind == .file or e.kind == .directory) {
+ try names.append(a, try a.dupe(u8, e.name));
+ };
+ } else return error.NotDir;
+ } else return error.NotDir;
+ std.mem.sort([]const u8, names.items, {}, struct {
+ fn less(_: void, x: []const u8, y: []const u8) bool {
+ return std.mem.lessThan(u8, x, y);
+ }
+ }.less);
+ return names.items;
+ }
+ fn serve(ctx: ?*anyopaque, conn: *Runner.Conn, req: fs.Req) void {
+ const cat: *Catalog = @ptrCast(@alignCast(ctx.?));
+ var arena = std.heap.ArenaAllocator.init(A);
+ defer arena.deinit();
+ // Controls take their own lock; all other node operations are serialized.
+ if (req.op == .write) {
+ cat.mutex.lockUncancelable(cat.io);
+ const path = if (req.node > 0 and req.node <= cat.nodes.items.len) cat.nodes.items[@intCast(req.node - 1)] else "";
+ const p = cat.sitePath(path);
+ cat.mutex.unlock(cat.io);
+ if (p) |s| {
+ if (std.mem.eql(u8, s.rest, "ctl") and req.off == 0 and req.data.len <= 128) {
+ cat.control(s.i, req.data) catch |err| {
+ conn.reply(&.{ .tag = req.tag, .status = .err, .ename = @errorName(err) }, "");
+ return;
+ };
+ conn.reply(&.{ .tag = req.tag, .written = @intCast(req.data.len) }, "");
+ return;
+ }
+ }
+ conn.reply(&fs.Reply.fail(req.tag, fs.E.PERM), "");
+ return;
+ }
+ cat.mutex.lockUncancelable(cat.io);
+ defer cat.mutex.unlock(cat.io);
+ cat.answer(arena.allocator(), conn, req) catch |err| conn.reply(&.{ .tag = req.tag, .status = .err, .ename = if (err == error.FileNotFound) "not found" else @errorName(err) }, "");
+ }
+ fn answer(cat: *Catalog, a: std.mem.Allocator, conn: *Runner.Conn, req: fs.Req) !void {
+ if (req.node == 0 or req.node > cat.nodes.items.len) return error.FileNotFound;
+ const path = cat.nodes.items[@intCast(req.node - 1)];
+ var reply: fs.Reply = .{ .tag = req.tag };
+ var bytes: []const u8 = "";
+ switch (req.op) {
+ .lookup => {
+ const next = if (std.mem.eql(u8, req.data, ".")) path else if (std.mem.eql(u8, req.data, "..")) (std.fs.path.dirname(path) orelse "") else try std.fs.path.join(a, &.{ path, req.data });
+ reply.attr = try cat.attr(a, next);
+ },
+ .getattr => reply.attr = try cat.attr(a, path),
+ .setattr => {
+ if (!std.mem.endsWith(u8, path, "/ctl")) return error.PermissionDenied;
+ reply.attr = try cat.attr(a, path);
+ },
+ .open => {
+ if ((req.omode & 3) != 0 and !std.mem.endsWith(u8, path, "/ctl")) return error.PermissionDenied;
+ if (std.mem.endsWith(u8, path, "/events")) {
+ var found = false;
+ for (&cat.cursors[conn.index], 0..) |*cursor, ci| if (!cursor.used) {
+ cursor.* = .{ .used = true };
+ reply.handle = @intCast(ci + 1);
+ found = true;
+ break;
+ };
+ if (!found) return error.TooManyEventReaders;
+ }
+ },
+ .release => {
+ if (req.opened and req.handle != 0) cat.cursors[conn.index][req.handle - 1].used = false;
+ },
+ .write => unreachable,
+ .read => {
+ if (cat.sitePath(path)) |p| {
+ if (std.mem.eql(u8, p.rest, "events") and req.handle != 0) {
+ const cursor = &cat.cursors[conn.index][req.handle - 1];
+ if (cursor.pos == cursor.len) {
+ if (cursor.revision == cat.states[p.i].revision) {
+ conn.reply(&.{ .tag = req.tag, .status = .again }, "");
+ return;
+ }
+ const json = try std.json.Stringify.valueAlloc(a, cat.states[p.i], .{});
+ if (json.len + 1 > cursor.bytes.len) return error.EventTooLarge;
+ @memcpy(cursor.bytes[0..json.len], json);
+ cursor.bytes[json.len] = '\n';
+ cursor.len = json.len + 1;
+ cursor.pos = 0;
+ cursor.revision = cat.states[p.i].revision;
+ }
+ const end = @min(cursor.len, cursor.pos + req.size);
+ bytes = cursor.bytes[cursor.pos..end];
+ cursor.pos = end;
+ conn.reply(&reply, bytes);
+ return;
+ }
+ if (std.mem.startsWith(u8, p.rest, "public/")) {
+ const f = try openBeneath(cat.io, cat.sites[p.i].root, p.rest[7..]);
+ defer f.close(cat.io);
+ const b = try a.alloc(u8, req.size);
+ bytes = b[0..try f.readPositionalAll(cat.io, b, req.off)];
+ conn.reply(&reply, bytes);
+ return;
+ }
+ }
+ const all = try cat.content(a, path);
+ const from = @min(req.off, all.len);
+ bytes = all[@intCast(from)..@intCast(@min(all.len, from + req.size))];
+ },
+ .readdir => {
+ var all: std.ArrayList(u8) = .empty;
+ const names = try cat.children(a, path);
+ // fs.Req.off is an ENTRY index, not the wire byte offset.
+ // The engine consumes compact node/dir/name records and owns
+ // Stat encoding plus the client's byte-offset cursor.
+ for (names[@intCast(@min(req.off, names.len))..]) |name| {
+ if (name.len > 255) continue;
+ const child_path = try std.fs.path.join(a, &.{ path, name });
+ const at = cat.attr(a, child_path) catch continue;
+ var header: [10]u8 = undefined;
+ std.mem.writeInt(u64, header[0..8], at.node, .little);
+ header[8] = @intFromBool(at.dir);
+ header[9] = @intCast(name.len);
+ try all.appendSlice(a, &header);
+ try all.appendSlice(a, name);
+ if (all.items.len >= req.size) break;
+ }
+ bytes = all.items;
+ },
+ }
+ conn.reply(&reply, bytes);
+ }
+};
+
+pub fn safeRelative(path: []const u8) bool {
+ if (std.fs.path.isAbsolute(path) or std.mem.indexOfScalar(u8, path, 0) != null or std.mem.indexOfScalar(u8, path, '\\') != null) return false;
+ var parts = std.mem.splitScalar(u8, path, '/');
+ while (parts.next()) |p| if (std.mem.eql(u8, p, "..") or std.mem.eql(u8, p, ".")) return false;
+ return true;
+}
+
+/// Descriptor-relative traversal refuses symlinks in every component, including
+/// the leaf. This also prevents TOCTOU escapes when a build replaces a directory.
+pub fn openBeneath(io: Io, root: []const u8, relative: []const u8) !Io.File {
+ if (!safeRelative(relative)) return error.AccessDenied;
+ var dir = try Io.Dir.cwd().openDir(io, root, .{});
+ defer dir.close(io);
+ var parts = std.mem.tokenizeScalar(u8, relative, '/');
+ var part = parts.next();
+ while (part) |p| {
+ part = parts.next();
+ if (part == null) return dir.openFile(io, p, .{ .follow_symlinks = false });
+ const next = try dir.openDir(io, p, .{ .follow_symlinks = false });
+ dir.close(io);
+ dir = next;
+ }
+ return dir.openFile(io, ".", .{ .follow_symlinks = false });
+}
+
+pub fn mime(path: []const u8) []const u8 {
+ const ext = std.fs.path.extension(path);
+ const types = .{ .{ ".html", "text/html; charset=utf-8" }, .{ ".css", "text/css" }, .{ ".js", "text/javascript" }, .{ ".mjs", "text/javascript" }, .{ ".json", "application/json" }, .{ ".svg", "image/svg+xml" }, .{ ".png", "image/png" }, .{ ".jpg", "image/jpeg" }, .{ ".jpeg", "image/jpeg" }, .{ ".gif", "image/gif" }, .{ ".webp", "image/webp" }, .{ ".ico", "image/x-icon" }, .{ ".woff2", "font/woff2" }, .{ ".woff", "font/woff" }, .{ ".pdf", "application/pdf" }, .{ ".wasm", "application/wasm" }, .{ ".txt", "text/plain; charset=utf-8" } };
+ inline for (types) |pair| if (std.ascii.eqlIgnoreCase(ext, pair[0])) return pair[1];
+ return "application/octet-stream";
+}
diff --git a/web/discover.py b/web/discover.py
new file mode 100644
index 0000000..8c750c1
--- /dev/null
+++ b/web/discover.py
@@ -0,0 +1,93 @@
+"""One-shot Linux listener inventory for 9web. Never connects to a listener.
+
+Only socket-inode ownership establishes a process/listener relationship. Parent
+commands can identify a launcher, but never turn an arbitrary Node socket into
+HTTP. Output deliberately omits full argv/environment (which may hold secrets).
+"""
+import ipaddress
+import json
+import os
+import socket
+import sys
+
+
+def recognize(argv):
+ if not argv:
+ return None
+ exe = os.path.basename(argv[0])
+ args = argv[1:]
+ if exe in ('miniserve', '9web'):
+ return exe, 'https' if '--tls-cert' in args else 'http', 'recognized executable'
+ if exe.startswith('python') and any(args[i:i+2] == ['-m', 'http.server'] for i in range(len(args))):
+ return 'python http.server', 'http', 'python -m http.server'
+ if exe == 'typst' and 'watch' in args:
+ return 'typst watch', 'http', 'typst watch'
+ # Require a CLI entrypoint, not a substring anywhere in arbitrary arguments.
+ if exe in ('node', 'nodejs', 'bun') and args:
+ entry = args[0].replace('\\', '/')
+ if entry.endswith(('/vite/bin/vite.js', '/vite/bin/vite.mjs')):
+ return 'vite', 'https' if '--https' in args else 'http', 'Vite CLI entrypoint'
+ if '/wrangler/' in entry and 'dev' in args:
+ return 'wrangler dev', 'http', 'Wrangler dev entrypoint'
+ return None
+
+
+def inventory(web_pid=None, web_ports=()):
+ owners = {}
+ for name in os.listdir('/proc'):
+ if not name.isdecimal():
+ continue
+ base = '/proc/' + name
+ try:
+ argv = open(base + '/cmdline', 'rb').read(65536).decode(errors='replace').rstrip('\0').split('\0')
+ exe = os.path.basename(os.readlink(base + '/exe'))
+ cwd = os.readlink(base + '/cwd')
+ fds = os.listdir(base + '/fd')
+ except (OSError, ValueError):
+ continue
+ recognized = recognize([exe] + argv[1:])
+ # 9web has both HTTP and 9P sockets. Its own configured listeners are
+ # supplied separately by the catalogue, never inferred from its name.
+ if exe == '9web':
+ recognized = None
+ for fd in fds:
+ try:
+ link = os.readlink(base + '/fd/' + fd)
+ except OSError:
+ continue
+ if link.startswith('socket:['):
+ owners.setdefault(link[8:-1], []).append(dict(
+ pid=int(name), process=exe, cwd=cwd, recognized=recognized))
+ rows = []
+ for table, family in [('tcp', socket.AF_INET), ('tcp6', socket.AF_INET6)]:
+ try:
+ lines = open('/proc/net/' + table).readlines()[1:]
+ except OSError:
+ continue
+ for line in lines:
+ fields = line.split()
+ if fields[3] != '0A':
+ continue
+ raw, port = fields[1].split(':')
+ packed = b''.join(int(raw[i:i+8], 16).to_bytes(4, sys.byteorder) for i in range(0, len(raw), 8))
+ address = socket.inet_ntop(family, packed)
+ inode = fields[9]
+ processes = {p['pid']: p for p in owners.get(inode, [])}
+ recognized = [p for p in processes.values() if p['recognized']]
+ p = recognized[0] if recognized else next(iter(processes.values()), None)
+ rec = p['recognized'] if p else None
+ if web_pid in processes and int(port, 16) in web_ports:
+ p = processes[web_pid]
+ rec = ('9web', 'http', '9web registered HTTP listener')
+ rows.append(dict(id=table + '-' + inode, address=address, port=int(port, 16),
+ protocol=rec[1] if rec else 'unknown', service=rec[0] if rec else None,
+ pid=p['pid'] if p else None, process=p['process'] if p else None,
+ cwd=p['cwd'] if p else None,
+ local=ipaddress.ip_address(address).is_loopback,
+ evidence=('socket inode ownership; ' + rec[2]) if rec else
+ ('socket inode ownership; unrecognized protocol' if p else 'process ownership unavailable')))
+ return sorted(rows, key=lambda r: (r['port'], r['address']))
+
+
+if __name__ == '__main__':
+ print(json.dumps(inventory(int(sys.argv[1]), [int(p) for p in sys.argv[2].split(',')]) if len(sys.argv) == 3 else inventory()))
diff --git a/web/main.zig b/web/main.zig
index 130ed4b..8c3d6ad 100644
--- a/web/main.zig
+++ b/web/main.zig
@@ -11,6 +11,7 @@ const c9 = @import("cloud9");
const mux = @import("mux.zig");
const httpfs = @import("httpfs.zig");
const probe = @import("probe.zig");
+const catalog = @import("catalog.zig");
const Io = std.Io;
const max_frame = 65536;
@@ -29,6 +30,7 @@ const Config = struct {
public_host: []const u8,
timeout_ms: u32,
browser_config: []const u8,
+ wildcard: bool = false,
};
/// One downstream slot: buffers, the HTTP/WebSocket streams and the mux
@@ -48,6 +50,7 @@ const Session = struct {
conn: MuxT.Conn = undefined,
wmutex: Io.Mutex = .init,
is_ws: bool = false,
+ site: ?usize = null,
fn sink(s: *Session) mux.Sink {
return .{ .ctx = s, .send = sendReply };
@@ -70,6 +73,7 @@ pub const App = struct {
io: Io,
m: *MuxT,
config: Config,
+ catalog: ?*catalog.Catalog = null,
sessions: [max_connections]Session = @splat(.{}),
active: std.atomic.Value(u32) = .init(0),
@@ -120,6 +124,10 @@ pub fn main(init: std.process.Init) !void {
var user: []const u8 = "user";
var tree: []const u8 = "";
var public_origin: ?[]const u8 = null;
+ var catalog_file: ?[]const u8 = null;
+ var catalog_socket: ?[]const u8 = null;
+ var state_dir: ?[]const u8 = null;
+ var explicit_upstream = false;
var i: usize = 1;
while (i < args.len) : (i += 1) {
if (std.mem.eql(u8, args[i], "--help")) {
@@ -127,6 +135,8 @@ pub fn main(init: std.process.Init) !void {
\\Usage: 9web [--listen IP:PORT] [--upstream tcp:IP:PORT|unix:PATH|file:PATH]
\\ [--serve tcp:IP:PORT|unix:PATH] [--probe unix:PATH|tcp:IP:PORT]
\\ [--origin https://HOST:PORT] [--timeout-ms 300000] [--user NAME] [--tree NAME]
+ \\ [--catalog FILE --catalog-socket PATH --state-dir PATH]
+ \\Catalogue mode serves configured sites, build controls and passive listener discovery.
\\One shared upstream, many downstreams. Default: http://127.0.0.1:8080 -> tcp:127.0.0.1:564
\\
, .{});
@@ -136,11 +146,36 @@ pub fn main(init: std.process.Init) !void {
i += 1;
const v = args[i];
const k = args[i - 1];
+ if (std.mem.eql(u8, k, "--catalog")) {
+ catalog_file = v;
+ continue;
+ }
+ if (std.mem.eql(u8, k, "--catalog-socket")) {
+ catalog_socket = v;
+ continue;
+ }
+ if (std.mem.eql(u8, k, "--state-dir")) {
+ state_dir = v;
+ continue;
+ }
+ if (std.mem.eql(u8, k, "--upstream")) explicit_upstream = true;
if (std.mem.eql(u8, k, "--listen")) listen_text = v else if (std.mem.eql(u8, k, "--upstream")) upstream_text = v else if (std.mem.eql(u8, k, "--serve")) serve_text = v else if (std.mem.eql(u8, k, "--probe")) probe_text = v else if (std.mem.eql(u8, k, "--origin")) public_origin = v else if (std.mem.eql(u8, k, "--timeout-ms")) timeout_ms = try std.fmt.parseInt(u32, v, 10) else if (std.mem.eql(u8, k, "--user")) user = v else if (std.mem.eql(u8, k, "--tree")) tree = v else return error.UnknownArgument;
}
if (user.len > 256 or tree.len > 256) return error.AttachNameTooLong;
const io = init.io;
+ var cat: ?*catalog.Catalog = null;
+ if (catalog_file) |file| {
+ if (@import("builtin").os.tag == .linux) {
+ if (explicit_upstream) return error.CatalogAndUpstreamAreExclusive;
+ const socket = catalog_socket orelse return error.MissingCatalogSocket;
+ cat = try catalog.Catalog.init(io, file, state_dir orelse return error.MissingStateDir);
+ cat.?.http_port = (try Io.net.IpAddress.parseLiteral(listen_text)).getPort();
+ try cat.?.start(try allocator.dupeSentinel(u8, socket, 0));
+ upstream_text = try std.fmt.allocPrint(allocator, "unix:{s}", .{socket});
+ } else return error.CatalogRequiresLinux;
+ }
+ defer if (cat) |c| c.stop();
const address = try Io.net.IpAddress.parseLiteral(listen_text);
const upstream = try parseUpstream(allocator, upstream_text);
@@ -167,12 +202,13 @@ pub fn main(init: std.process.Init) !void {
origin_uri.path.percent_encoded.len != 0 or origin_uri.query != null or origin_uri.fragment != null) return error.InvalidOrigin;
const browser_config = try std.json.Stringify.valueAlloc(allocator, .{ .user = user, .tree = tree }, .{});
- var app: App = .{ .io = io, .m = &m, .config = .{
+ var app: App = .{ .io = io, .m = &m, .catalog = cat, .config = .{
.host = host,
.origin = origin_text,
.public_host = origin_text[origin_uri.scheme.len + 3 ..],
.timeout_ms = timeout_ms,
.browser_config = browser_config,
+ .wildcard = std.mem.startsWith(u8, listen_text, "0.0.0.0:") or std.mem.startsWith(u8, listen_text, "[::]:"),
} };
std.debug.print("9web {s} -> {s}\n", .{ app.config.origin, upstream_text });
@@ -181,6 +217,19 @@ pub fn main(init: std.process.Init) !void {
defer group.cancel(io);
try group.concurrent(io, MuxT.readerLoop, .{&m});
+ // Each site gets its own HTTP root, preserving /assets and /blog links.
+ // These listeners belong to this same 9web process, not preview daemons.
+ if (cat) |c| {
+ for (c.sites, 0..) |site, si| {
+ const l = try allocator.create(Io.net.Server);
+ var bind_address = address;
+ bind_address.setPort(site.port);
+ l.* = try c9.transport.listen(io, .{ .tcp = bind_address }, max_connections);
+ try group.concurrent(io, siteAcceptLoop, .{ &app, l, &group, si });
+ std.debug.print("9web: site {s} on {f} from {s}\n", .{ site.name, l.socket.address, site.root });
+ }
+ }
+
// Optional 9P listener for plan9port / 9ns clients (a mux like 9pserve).
var serve_listener: ?Io.net.Server = null;
if (serve_text) |t| {
@@ -216,6 +265,7 @@ pub fn main(init: std.process.Init) !void {
continue;
};
s.app = &app;
+ s.site = null;
s.stream = stream;
group.concurrent(io, handleHttp, .{s}) catch {
app.giveBack(s);
@@ -225,6 +275,24 @@ pub fn main(init: std.process.Init) !void {
}
}
+fn siteAcceptLoop(app: *App, listener: *Io.net.Server, group: *Io.Group, si: usize) void {
+ defer listener.deinit(app.io);
+ while (true) {
+ const stream = listener.accept(app.io) catch return;
+ const s = app.take() orelse {
+ stream.close(app.io);
+ continue;
+ };
+ s.app = app;
+ s.stream = stream;
+ s.site = si;
+ group.concurrent(app.io, handleHttp, .{s}) catch {
+ app.giveBack(s);
+ stream.close(app.io);
+ };
+ }
+}
+
/// Accepts plain 9P clients on the `--serve` listener; each runs a raw mux
/// session for its lifetime.
fn serveLoop(app: *App, listener: *Io.net.Server, group: *Io.Group) void {
@@ -318,15 +386,48 @@ fn serveHttp(s: *Session) !void {
if (std.ascii.eqlIgnoreCase(header.name, "origin")) origin = header.value;
if (std.ascii.eqlIgnoreCase(header.name, "sec-websocket-version")) version = header.value;
}
- if (!std.mem.eql(u8, host orelse "", config.host) and !std.mem.eql(u8, host orelse "", config.public_host))
+ if (s.site) |si| return serveSite(s, &request, app.catalog.?.sites[si]);
+ const host_text = host orelse "";
+ const literal = Io.net.IpAddress.parseLiteral(host_text) catch null;
+ const bound = try Io.net.IpAddress.parseLiteral(config.host);
+ const wildcard_host = config.wildcard and ((if (literal) |ip| ip.getPort() == bound.getPort() else false) or std.mem.eql(u8, host_text, try std.fmt.bufPrint(&s.body, "localhost:{d}", .{bound.getPort()})));
+ if (!wildcard_host and !std.mem.eql(u8, host_text, config.host) and !std.mem.eql(u8, host_text, config.public_host))
return respond(&request, "Unexpected Host\n", "text/plain", .forbidden);
const path = std.mem.sliceTo(request.head.target, '?');
+ // Browsers must originate control writes from this dashboard. Site ports
+ // are separate origins. CLI and 9P clients do not send Origin.
+ const same_origin = if (origin) |o| std.mem.eql(u8, o, config.origin) or
+ (std.mem.startsWith(u8, o, "http://") and std.mem.eql(u8, o[7..], host_text)) else false;
+ if (app.catalog) |c| {
+ if (request.head.method != .GET and request.head.method != .HEAD and origin != null and !same_origin)
+ return respond(&request, "Unexpected Origin\n", "text/plain", .forbidden);
+ if (std.mem.eql(u8, path, "/")) return respond(&request, @embedFile("static/catalog.html"), "text/html; charset=utf-8", .ok);
+ if (std.mem.eql(u8, path, "/_cloud9/catalog.js")) return respond(&request, @embedFile("static/catalog.js"), "text/javascript", .ok);
+ if (std.mem.eql(u8, path, "/_cloud9/catalog.json")) {
+ var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
+ defer arena.deinit();
+ return respond(&request, try c.snapshot(arena.allocator()), "application/json", .ok);
+ }
+ if (std.mem.startsWith(u8, path, "/_cloud9/sites/") and std.mem.endsWith(u8, path, "/ctl")) {
+ if (request.head.method != .POST) return respond(&request, "Use POST\n", "text/plain", .method_not_allowed);
+ const name = path[15 .. path.len - 4];
+ for (c.sites, 0..) |site, si| if (std.mem.eql(u8, name, site.name)) {
+ var body_buf: [256]u8 = undefined;
+ const reader = try request.readerExpectContinue(&body_buf);
+ const command = reader.allocRemaining(std.heap.page_allocator, .limited(128)) catch return respond(&request, "Command too long\n", "text/plain", .bad_request);
+ defer std.heap.page_allocator.free(command);
+ c.control(si, command) catch |err| return respond(&request, @errorName(err), "text/plain", .bad_request);
+ return respond(&request, "queued\n", "text/plain", .accepted);
+ };
+ return respond(&request, "Unknown site\n", "text/plain", .not_found);
+ }
+ }
// The WebSocket endpoint.
if (std.mem.eql(u8, path, "/_cloud9/9p")) {
if (request.head.method != .GET) return respond(&request, "Use GET\n", "text/plain", .method_not_allowed);
- if (!std.mem.eql(u8, origin orelse "", config.origin)) return respond(&request, "Unexpected Origin\n", "text/plain", .forbidden);
+ if (!same_origin) return respond(&request, "Unexpected Origin\n", "text/plain", .forbidden);
if (!std.mem.eql(u8, version orelse "", "13")) return respond(&request, "WebSocket version 13 required\n", "text/plain", .bad_request);
return wsSession(s, &request);
}
@@ -375,3 +476,92 @@ fn wsSession(s: *Session, request: *std.http.Server.Request) !void {
}
}
}
+
+fn serveSite(s: *Session, request: *std.http.Server.Request, site: catalog.Site) !void {
+ if (request.head.method != .GET and request.head.method != .HEAD) return respond(request, "Use GET or HEAD\n", "text/plain", .method_not_allowed);
+ const raw = std.mem.sliceTo(request.head.target, '?');
+ if (raw.len == 0 or raw[0] != '/') return respond(request, "Bad path\n", "text/plain", .bad_request);
+ var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
+ defer arena.deinit();
+ const a = arena.allocator();
+ const decoded = try a.alloc(u8, raw.len);
+ var n: usize = 0;
+ var i: usize = 1;
+ while (i < raw.len) : (i += 1) {
+ var ch = raw[i];
+ if (ch == '%') {
+ if (i + 2 >= raw.len) return respond(request, "Bad escape\n", "text/plain", .bad_request);
+ ch = std.fmt.parseInt(u8, raw[i + 1 .. i + 3], 16) catch return respond(request, "Bad escape\n", "text/plain", .bad_request);
+ if (ch == '/' or ch == '\\') return respond(request, "Bad escape\n", "text/plain", .bad_request);
+ i += 2;
+ }
+ decoded[n] = ch;
+ n += 1;
+ }
+ var rel: []const u8 = decoded[0..n];
+ if (!catalog.safeRelative(rel)) return respond(request, "Forbidden path\n", "text/plain", .forbidden);
+ // Dotfiles and builder/provider configuration are not public documents.
+ var components = std.mem.tokenizeScalar(u8, rel, '/');
+ while (components.next()) |component| if (component[0] == '.' or std.mem.eql(u8, component, "_headers") or std.mem.eql(u8, component, "_redirects")) return respond(request, "Not found\n", "text/plain", .not_found);
+ var file = catalog.openBeneath(s.app.io, site.root, rel) catch blk: {
+ // Pretty URLs such as /blog/post resolve to /blog/post.html.
+ if (std.fs.path.extension(rel).len != 0) return respond(request, "Not found\n", "text/plain", .not_found);
+ rel = try std.fmt.allocPrint(a, "{s}.html", .{rel});
+ break :blk catalog.openBeneath(s.app.io, site.root, rel) catch return respond(request, "Not found\n", "text/plain", .not_found);
+ };
+ var st = try file.stat(s.app.io);
+ if (st.kind == .directory) {
+ file.close(s.app.io);
+ if (!std.mem.endsWith(u8, raw, "/")) {
+ const location = try std.fmt.allocPrint(a, "{s}/", .{raw});
+ return request.respond("", .{ .status = .moved_permanently, .keep_alive = false, .extra_headers = &.{.{ .name = "location", .value = location }} });
+ }
+ rel = try std.fs.path.join(a, &.{ rel, "index.html" });
+ file = catalog.openBeneath(s.app.io, site.root, rel) catch return respond(request, "Site has not been built, or index.html is missing.\n", "text/plain", .not_found);
+ st = try file.stat(s.app.io);
+ }
+ defer file.close(s.app.io);
+ if (st.kind != .file) return respond(request, "Not a regular file\n", "text/plain", .forbidden);
+ var start: u64 = 0;
+ var end = st.size;
+ var partial = false;
+ var headers = request.iterateHeaders();
+ while (headers.next()) |h| if (std.ascii.eqlIgnoreCase(h.name, "range")) {
+ const text = h.value;
+ if (!std.mem.startsWith(u8, text, "bytes=") or std.mem.indexOfScalar(u8, text, ',') != null) return respond(request, "Unsupported range\n", "text/plain", .range_not_satisfiable);
+ const dash = std.mem.indexOfScalar(u8, text[6..], '-') orelse return respond(request, "Bad range\n", "text/plain", .range_not_satisfiable);
+ const left = text[6 .. 6 + dash];
+ const right = text[7 + dash ..];
+ if (left.len == 0) {
+ const suffix = std.fmt.parseInt(u64, right, 10) catch return respond(request, "Bad range\n", "text/plain", .range_not_satisfiable);
+ start = st.size - @min(st.size, suffix);
+ } else {
+ start = std.fmt.parseInt(u64, left, 10) catch return respond(request, "Bad range\n", "text/plain", .range_not_satisfiable);
+ if (right.len != 0) {
+ const last = std.fmt.parseInt(u64, right, 10) catch return respond(request, "Bad range\n", "text/plain", .range_not_satisfiable);
+ end = @min(st.size, last +| 1);
+ }
+ }
+ if (start >= end) return respond(request, "Unsatisfiable range\n", "text/plain", .range_not_satisfiable);
+ partial = true;
+ };
+ var extra: std.ArrayList(std.http.Header) = .empty;
+ try extra.appendSlice(a, &.{ .{ .name = "content-type", .value = catalog.mime(rel) }, .{ .name = "cache-control", .value = "no-cache" }, .{ .name = "x-content-type-options", .value = "nosniff" }, .{ .name = "accept-ranges", .value = "bytes" } });
+ if (partial) try extra.append(a, .{ .name = "content-range", .value = try std.fmt.allocPrint(a, "bytes {d}-{d}/{d}", .{ start, end - 1, st.size }) });
+ if (request.head.method == .HEAD) {
+ try extra.append(a, .{ .name = "content-length", .value = try std.fmt.allocPrint(a, "{d}", .{end - start}) });
+ return request.respond("", .{ .status = if (partial) .partial_content else .ok, .keep_alive = false, .transfer_encoding = .none, .extra_headers = extra.items });
+ }
+ var bw = try request.respondStreaming(&s.body, .{ .content_length = end - start, .respond_options = .{ .status = if (partial) .partial_content else .ok, .keep_alive = false, .extra_headers = extra.items } });
+ if (request.head.method != .HEAD) {
+ var offset = start;
+ while (offset < end) {
+ const count: usize = @intCast(@min(end - offset, s.frame.len));
+ const got = try file.readPositionalAll(s.app.io, s.frame[0..count], offset);
+ if (got == 0) return error.EndOfStream;
+ try bw.writer.writeAll(s.frame[0..got]);
+ offset += got;
+ }
+ }
+ try bw.end();
+}
diff --git a/web/static/catalog.html b/web/static/catalog.html
new file mode 100644
index 0000000..2160612
--- /dev/null
+++ b/web/static/catalog.html
@@ -0,0 +1,14 @@
+<!doctype html>
+<html lang="en"><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
+<title>9web · local sites</title>
+<style>
+:root{color-scheme:light dark;font:16px/1.5 system-ui;background:#151917;color:#e3e9df}body{max-width:1100px;margin:3rem auto;padding:0 1.5rem}h1{font-size:2.5rem;margin-bottom:0}a{color:#b8dfa6}header p{color:#aab8a6}.sites{display:grid;grid-template-columns:repeat(auto-fit,minmax(290px,1fr));gap:1rem}article{background:#212922;border:1px solid #3c4b3c;border-radius:10px;padding:1.2rem}article h2{margin:0 0 .6rem;font-size:1.3rem}code,pre{font:13px/1.5 monospace;overflow-wrap:anywhere}button{background:#324631;color:inherit;border:1px solid #61765a;border-radius:5px;padding:.4rem .7rem;cursor:pointer;margin:.4rem .3rem .1rem 0}button:disabled{opacity:.4}table{width:100%;border-collapse:collapse}td,th{text-align:left;border-bottom:1px solid #354234;padding:.6rem;overflow-wrap:anywhere}th{color:#aab8a6}pre{max-height:35rem;overflow:auto;background:#101410;padding:1rem;white-space:pre-wrap}small{color:#aab8a6}.error{color:#ffb4a9}.toolbar{display:flex;gap:1rem;align-items:center}dialog{width:min(850px,85vw);background:#212922;color:inherit;border:1px solid #61765a}#message{min-height:1.5em}details{margin-top:1.5rem}@media(max-width:650px){td,th{padding:.4rem;font-size:13px}.process{display:none}}
+</style>
+<header><h1>9web</h1><p>Local sites, builds, and listening services.</p></header>
+<p id="message" role="status"></p><main><div id="sites" class="sites"></div>
+<div class="toolbar"><h2>HTTP services</h2><a href="/fs/">9P tree</a></div>
+<p><small>Identified from socket ownership and process arguments. No endpoint probing. Loopback links work only on this computer.</small></p>
+<table><thead><tr><th>Service</th><th>Address</th><th class="process">Process</th><th>Evidence</th></tr></thead><tbody id="services"></tbody></table>
+<details><summary id="unknown-title">Other listeners</summary><table><tbody id="unknown"></tbody></table></details></main>
+<dialog id="logs"><button id="close-log">Close</button><h2 id="log-title"></h2><pre id="log-text"></pre></dialog>
+<script src="/_cloud9/catalog.js"></script></html>
diff --git a/web/static/catalog.js b/web/static/catalog.js
new file mode 100644
index 0000000..f868a16
--- /dev/null
+++ b/web/static/catalog.js
@@ -0,0 +1,56 @@
+const $ = id => document.getElementById(id);
+let activeLog = null;
+const element = (tag, text) => { const e = document.createElement(tag); e.textContent = text; return e; };
+function url(address, port, protocol = 'http') {
+ let host = address;
+ if (!host || host === '0.0.0.0' || host === '::') host = location.hostname;
+ host = host.replace(/^\[|\]$/g, '');
+ return `${protocol}://${host.includes(':') ? `[${host}]` : host}:${port}/`;
+}
+async function control(name, command) {
+ try {
+ const r = await fetch(`/_cloud9/sites/${encodeURIComponent(name)}/ctl`, { method:'POST', headers:{'Content-Type':'text/plain'}, body:command });
+ if (!r.ok) throw new Error(await r.text());
+ $('message').textContent = `${name}: ${command} requested`;
+ await refresh();
+ } catch (e) { $('message').textContent = e.message; }
+}
+function button(text, action, disabled = false) { const b = element('button', text); b.disabled = disabled; b.onclick = action; return b; }
+function listenerRow(item) {
+ const tr = element('tr', '');
+ const name = element('td', '');
+ if (item.protocol !== 'unknown') {
+ const a = element('a', item.service); a.href = url(item.address, item.port, item.protocol); name.append(a);
+ } else name.textContent = item.process || 'Unknown';
+ tr.append(name, element('td', `${item.address}:${item.port}${item.local ? ' · local only' : ''}`));
+ const process = element('td', item.pid ? `PID ${item.pid}` : 'Unavailable'); process.className = 'process'; tr.append(process, element('td', item.evidence));
+ return tr;
+}
+async function refresh() {
+ try {
+ const r = await fetch('/_cloud9/catalog.json'); if (!r.ok) throw new Error(`Dashboard: ${r.status}`);
+ const data = await r.json();
+ $('sites').replaceChildren();
+ for (const site of data.sites) {
+ const card = element('article', ''); const h = element('h2', ''); const a = element('a', site.title); a.href = url('', site.port); h.append(a);
+ const s = site.status;
+ card.append(h, element('code', site.root), element('p', `${s.phase}${s.watching ? ' · watch on' : ''}${s.queued ? ' · build queued' : ''}${s.exit_code !== null ? ` · exit ${s.exit_code}` : ''}`));
+ if (s.finished) card.append(element('small', `Last finished ${new Date(s.finished * 1000).toLocaleString()}`), element('br', ''));
+ card.append(button('Build', () => control(site.name, 'build'), !site.build), button(s.watching ? 'Stop watching' : 'Watch', () => control(site.name, s.watching ? 'watch off' : 'watch on'), !site.watch), button('Cancel', () => control(site.name, 'cancel'), !s.pid && !s.queued), button('Log', () => { activeLog = site.name; $('log-title').textContent = site.title; $('logs').showModal(); refreshLog(); }));
+ $('sites').append(card);
+ }
+ const known = data.listeners.filter(x => x.protocol !== 'unknown');
+ const unknown = data.listeners.filter(x => x.protocol === 'unknown');
+ $('services').replaceChildren(...known.map(listenerRow));
+ $('unknown').replaceChildren(...unknown.map(listenerRow));
+ $('unknown-title').textContent = `Other listeners (${unknown.length})`;
+ if (data.discovery_error) $('message').textContent = data.discovery_error;
+ } catch (e) { $('message').textContent = e.message; }
+}
+async function refreshLog() {
+ if (!activeLog) return;
+ try { const r = await fetch(`/fs/sites/${encodeURIComponent(activeLog)}/log`); $('log-text').textContent = await r.text(); } catch (e) { $('log-text').textContent = e.message; }
+}
+$('close-log').onclick = () => { activeLog = null; $('logs').close(); };
+$('logs').onclose = () => { activeLog = null; };
+refresh(); setInterval(refresh, 5000); setInterval(refreshLog, 1500);