@johnhenry/sitefile 0.0.0-stage → 0.0.0

package/lib/src/serve-rules.js

@@ -0,0 +1,122 @@
+// `_redirects` and `_headers` as `sitefile serve` reads them (docs/CLI.md, "serve").
+// Ported as the rules section of rust/src/server.rs.
+import { safeSegments } from './server.js';
+const HEADER_TOKEN = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
+/** Headers the server owns; `_headers` cannot set them. */
+const PROTECTED_HEADERS = new Set(['content-length', 'transfer-encoding', 'connection', 'keep-alive', 'etag', 'location']);
+const SERVE_STATUSES = new Set([200, 301, 302, 303, 307, 308, 404]);
+/**
+ * Parse `_redirects`: `from to [status[!]]` per line, `#` comments. Supported: exact paths and a
+ * trailing `/*` with `:splat` in the target; statuses 301, 302, 303, 307, 308 (redirect), 200
+ * (rewrite) and 404. Other lines (placeholders, conditions, query matching) are ignored.
+ */
+export function parseRedirectRules(text) {
+    const out = [];
+    for (const line of text.split('\n')) {
+        const t = line.trim();
+        if (t === '' || t.startsWith('#'))
+            continue;
+        const fields = t.split(/[ \t]+/);
+        if (fields.length < 2 || fields.length > 3)
+            continue;
+        const from = fields[0];
+        const to = fields[1];
+        const st = fields[2] ?? '301';
+        const force = st.endsWith('!');
+        const code = force ? st.slice(0, -1) : st;
+        if (!/^[0-9]{3}$/.test(code) || !SERVE_STATUSES.has(Number(code)))
+            continue;
+        const status = Number(code);
+        if (!/^[\x21-\x7e]+$/.test(to) || !(to.startsWith('/') || /^https?:\/\/[^/]/i.test(to)))
+            continue;
+        if ((status === 200 || status === 404) && !to.startsWith('/'))
+            continue;
+        if (!from.startsWith('/'))
+            continue;
+        const splat = from === '/*' || from.endsWith('/*');
+        const prefix = splat ? from.slice(0, -2) : from;
+        if (prefix.includes('*') || prefix.split('/').some((seg) => seg.startsWith(':')))
+            continue;
+        const segs = safeSegments(prefix === '' ? '/' : prefix);
+        if (!segs)
+            continue;
+        const decoded = '/' + segs.join('/');
+        out.push({ from: splat && decoded === '/' ? '' : decoded, splat, to, status, force });
+    }
+    return out;
+}
+/** Parse `_headers`: a path pattern line (`*` matches anything), then indented `Name: value` lines. */
+export function parseHeaderRules(text) {
+    const out = [];
+    let cur;
+    for (const raw of text.split('\n')) {
+        const line = raw.endsWith('\r') ? raw.slice(0, -1) : raw;
+        const t = line.trim();
+        if (t === '' || t.startsWith('#'))
+            continue;
+        if (line[0] === ' ' || line[0] === '\t') {
+            const i = t.indexOf(':');
+            if (!cur || i <= 0)
+                continue;
+            const name = t.slice(0, i).trim().toLowerCase();
+            const value = t.slice(i + 1).trim();
+            if (!HEADER_TOKEN.test(name) || !/^[\t\x20-\x7e]*$/.test(value) || PROTECTED_HEADERS.has(name))
+                continue;
+            cur.headers.push([name, value]);
+            continue;
+        }
+        cur = t.startsWith('/') ? { pattern: t, headers: [] } : undefined;
+        if (cur)
+            out.push(cur);
+    }
+    return out;
+}
+/** Glob match where `*` matches any run of characters (including `/`). */
+export function globMatch(pattern, s) {
+    let p = 0;
+    let i = 0;
+    let star = -1;
+    let mark = 0;
+    while (i < s.length) {
+        if (p < pattern.length && pattern[p] !== '*' && pattern[p] === s[i]) {
+            p++;
+            i++;
+        }
+        else if (p < pattern.length && pattern[p] === '*') {
+            star = p++;
+            mark = i;
+        }
+        else if (star >= 0) {
+            p = star + 1;
+            i = ++mark;
+        }
+        else {
+            return false;
+        }
+    }
+    while (pattern[p] === '*')
+        p++;
+    return p === pattern.length;
+}
+/** Every matching block's headers; a name set by several blocks gets its values joined with `, `. */
+export function headersFor(rules, path) {
+    const out = {};
+    for (const r of rules) {
+        if (!globMatch(r.pattern, path))
+            continue;
+        for (const [k, v] of r.headers)
+            out[k] = out[k] === undefined ? v : `${out[k]}, ${v}`;
+    }
+    return out;
+}
+/** The remainder a rule matches for `path` (`''` for the prefix itself), or undefined. */
+export function matchRedirect(r, path) {
+    if (!r.splat)
+        return path === r.from ? '' : undefined;
+    if (r.from === '')
+        return path.slice(1);
+    if (path === r.from)
+        return '';
+    return path.startsWith(r.from + '/') ? path.slice(r.from.length + 1) : undefined;
+}
+//# sourceMappingURL=serve-rules.js.map

package/lib/src/server.d.ts

@@ -0,0 +1,45 @@
+import http from 'node:http';
+import type { Tree } from './tree.js';
+export interface SiteServerOptions {
+    /** Fall back to `/index.html` for unknown extension-less paths (single-page apps). */
+    readonly spa?: boolean;
+    /** One access-log line per request: `METHOD /path STATUS BYTES MSms`. */
+    readonly log?: (line: string) => void;
+    /** Sent as `x-sitefile-server` so `servers` can tell its own servers from a reused port. */
+    readonly serverId?: string;
+    /**
+     * `serve --watch`: answer {@link RELOAD_PATH} with an event stream and add
+     * {@link RELOAD_SCRIPT} to HTML responses. Never set otherwise, and never written to exports.
+     */
+    readonly liveReload?: LiveReload;
+}
+/** Reserved for the live-reload event stream while `serve --watch` runs. */
+export declare const RELOAD_PATH = "/__sitefile/reload";
+/** Added to served HTML (before the last `</body>`, else at the end) under `serve --watch`. */
+export declare const RELOAD_SCRIPT = "<script>new EventSource(\"/__sitefile/reload\").onmessage=function(){location.reload()}</script>";
+/** Open live-reload streams; {@link LiveReload.reload} tells every page to reload. */
+export declare class LiveReload {
+    private readonly clients;
+    /** Hold `res` open as a text/event-stream until the client goes away. */
+    attach(res: http.ServerResponse, headers: Record<string, string>): void;
+    reload(): void;
+    get size(): number;
+}
+/** `html` with {@link RELOAD_SCRIPT} inserted before the last `</body` (ASCII case-insensitive), else appended. */
+export declare function injectReloadScript(html: Uint8Array): Uint8Array;
+/** Decode a request path into safe segments, or undefined when it is malformed or unsafe. */
+export declare function safeSegments(rawPath: string): string[] | undefined;
+/**
+ * An HTTP server for an immutable Tree. GET and HEAD only; nothing outside the tree is
+ * ever reachable because lookups are exact map keys built from validated segments.
+ * Honours `/404.html`, `/_redirects` and `/_headers` (which it never serves), and answers
+ * `/about` with `/about.html` when there is no such file or directory.
+ */
+export declare function createSiteServer(site: Tree | (() => Tree), options?: SiteServerOptions): http.Server;
+/** Listen on host:port (port 0 = any free port); EADDRINUSE and friends become E_SERVER. */
+export declare function listen(server: http.Server, host: string, port: number): Promise<{
+    host: string;
+    port: number;
+}>;
+export declare function closeServer(server: http.Server): Promise<void>;
+export declare function formatUrl(host: string, port: number): string;

package/lib/src/server.js

@@ -0,0 +1,246 @@
+import http from 'node:http';
+import { SitefileError } from './errors.js';
+import { headersFor, matchRedirect, parseHeaderRules, parseRedirectRules } from './serve-rules.js';
+import { nfc } from './paths.js';
+import { mimeTypeFor } from './wbn.js';
+/** Reserved for the live-reload event stream while `serve --watch` runs. */
+export const RELOAD_PATH = '/__sitefile/reload';
+/** Added to served HTML (before the last `</body>`, else at the end) under `serve --watch`. */
+export const RELOAD_SCRIPT = `<script>new EventSource("${RELOAD_PATH}").onmessage=function(){location.reload()}</script>`;
+/** Open live-reload streams; {@link LiveReload.reload} tells every page to reload. */
+export class LiveReload {
+    clients = new Set();
+    /** Hold `res` open as a text/event-stream until the client goes away. */
+    attach(res, headers) {
+        res.writeHead(200, { ...headers, 'content-type': 'text/event-stream', 'cache-control': 'no-cache' });
+        res.write('retry: 1000\n\n');
+        this.clients.add(res);
+        res.on('close', () => this.clients.delete(res));
+    }
+    reload() {
+        for (const c of this.clients)
+            c.write('data: reload\n\n');
+    }
+    get size() {
+        return this.clients.size;
+    }
+}
+/** `html` with {@link RELOAD_SCRIPT} inserted before the last `</body` (ASCII case-insensitive), else appended. */
+export function injectReloadScript(html) {
+    const buf = Buffer.from(html.buffer, html.byteOffset, html.byteLength);
+    const at = buf.toString('latin1').toLowerCase().lastIndexOf('</body');
+    const script = Buffer.from(RELOAD_SCRIPT);
+    return at === -1 ? Buffer.concat([buf, script]) : Buffer.concat([buf.subarray(0, at), script, buf.subarray(at)]);
+}
+const NOT_FOUND_PAGE = '<!doctype html><meta charset="utf-8"><title>404 Not Found</title><h1>404 Not Found</h1>\n';
+const BAD_REQUEST_PAGE = '<!doctype html><meta charset="utf-8"><title>400 Bad Request</title><h1>400 Bad Request</h1>\n';
+const METHOD_PAGE = '<!doctype html><meta charset="utf-8"><title>405 Method Not Allowed</title><h1>405 Method Not Allowed</h1>\n';
+/** Decode a request path into safe segments, or undefined when it is malformed or unsafe. */
+export function safeSegments(rawPath) {
+    if (!rawPath.startsWith('/') || rawPath.includes('\\') || rawPath.includes('\0'))
+        return undefined;
+    const out = [];
+    for (const raw of rawPath.split('/')) {
+        if (raw === '')
+            continue;
+        let seg;
+        try {
+            seg = decodeURIComponent(raw);
+        }
+        catch {
+            return undefined;
+        }
+        // A decoded '/', '\\', NUL, control character, '.' or '..' could change what is read.
+        if (seg === '.' || seg === '..' || /[\\/\u0000-\u001f\u007f]/.test(seg))
+            return undefined;
+        // Tree paths are NFC; a request for an NFD spelling finds the same file.
+        out.push(nfc(seg));
+    }
+    return out;
+}
+function etagMatches(header, etag) {
+    if (header === undefined)
+        return false;
+    if (header.trim() === '*')
+        return true;
+    return header.split(',').some((t) => t.trim().replace(/^W\//, '') === etag);
+}
+function printable(s) {
+    return s.replace(/[^\x21-\x7e]/g, (c) => `%${c.charCodeAt(0).toString(16).padStart(2, '0')}`).slice(0, 512);
+}
+/**
+ * An HTTP server for an immutable Tree. GET and HEAD only; nothing outside the tree is
+ * ever reachable because lookups are exact map keys built from validated segments.
+ * Honours `/404.html`, `/_redirects` and `/_headers` (which it never serves), and answers
+ * `/about` with `/about.html` when there is no such file or directory.
+ */
+export function createSiteServer(site, options = {}) {
+    // A function is read per request (`serve --watch` swaps in each good rebuild).
+    const current = typeof site === 'function' ? site : () => site;
+    const base = { 'x-content-type-options': 'nosniff', 'cache-control': 'no-cache' };
+    if (options.serverId)
+        base['x-sitefile-server'] = options.serverId;
+    // `_redirects` / `_headers` are parsed once per tree (a watched server gets a new tree per rebuild).
+    let rulesTree;
+    let rules = { redirects: [], headers: [] };
+    const rulesFor = (t) => {
+        if (t !== rulesTree) {
+            const text = (p) => {
+                const f = t.get(p);
+                return f ? new TextDecoder().decode(f.bytes) : '';
+            };
+            rules = { redirects: parseRedirectRules(text('/_redirects')), headers: parseHeaderRules(text('/_headers')) };
+            rulesTree = t;
+        }
+        return rules;
+    };
+    const handler = (req, res) => {
+        const started = process.hrtime.bigint();
+        const method = req.method ?? 'GET';
+        const url = req.url ?? '/';
+        let bytes = 0;
+        const finish = (status, headers, body) => {
+            const buf = body === undefined ? undefined : typeof body === 'string' ? Buffer.from(body) : body;
+            res.writeHead(status, { ...base, ...headers });
+            if (buf !== undefined && method !== 'HEAD' && status !== 304) {
+                bytes = buf.byteLength;
+                res.end(buf);
+            }
+            else {
+                res.end();
+            }
+            const ms = Number((process.hrtime.bigint() - started) / 1000n) / 1000;
+            // `servers` probes carry the server's own id; they would only clutter the access log.
+            if (options.serverId !== undefined && req.headers['x-sitefile-probe'] === options.serverId)
+                return;
+            options.log?.(`${method} ${printable(url)} ${status} ${bytes} ${ms.toFixed(1)}ms`);
+        };
+        const page = (status, html, extra = {}) => finish(status, { 'content-type': 'text/html; charset=utf-8', 'content-length': Buffer.byteLength(html), ...extra }, html);
+        if (method !== 'GET' && method !== 'HEAD')
+            return page(405, METHOD_PAGE, { allow: 'GET, HEAD' });
+        const tree = current();
+        const { redirects, headers: headerRules } = rulesFor(tree);
+        const isFile = (p) => tree.isFile(p) && p !== '/_redirects' && p !== '/_headers';
+        const q = url.indexOf('?');
+        const hash = url.indexOf('#');
+        const end = Math.min(q === -1 ? url.length : q, hash === -1 ? url.length : hash);
+        const rawPath = url.slice(0, end);
+        if (options.liveReload && rawPath === RELOAD_PATH) {
+            if (method === 'HEAD')
+                return finish(200, { 'content-type': 'text/event-stream' }, undefined);
+            return options.liveReload.attach(res, base); // not access-logged: one long request per open page
+        }
+        const search = q === -1 ? '' : url.slice(q, hash === -1 || hash < q ? undefined : hash);
+        const segs = safeSegments(rawPath);
+        if (!segs)
+            return page(400, BAD_REQUEST_PAGE);
+        const trailingSlash = rawPath.endsWith('/');
+        const vpath = '/' + segs.join('/');
+        // `_headers` patterns match the request path (with its trailing slash).
+        const custom = headersFor(headerRules, vpath + (trailingSlash && segs.length > 0 ? '/' : ''));
+        const sendFile = (status, served) => {
+            const file = tree.get(served);
+            const type = mimeTypeFor(served);
+            const live = options.liveReload !== undefined && type.startsWith('text/html');
+            const body = live ? injectReloadScript(file.bytes) : file.bytes;
+            if (status !== 200)
+                return finish(status, { 'content-type': type, 'content-length': body.byteLength, ...custom }, body);
+            // An injected page is a different representation of the file: give it its own ETag.
+            const etag = `"${file.digest.replace(/^sha256:/, '')}${live ? '-live' : ''}"`;
+            if (etagMatches(req.headers['if-none-match'], etag))
+                return finish(304, { ...custom, etag }, undefined);
+            finish(200, { 'content-type': type, 'content-length': body.byteLength, ...custom, etag }, body);
+        };
+        /** The file for a path: exact, `<path>.html` (clean URLs), or `<dir>/index.html` with a trailing slash. */
+        const resolve = (p, slash) => {
+            if (isFile(p) && !(slash && p !== '/'))
+                return p;
+            if (!slash && p !== '/' && isFile(`${p}.html`))
+                return `${p}.html`;
+            if (slash && tree.isDirectory(p)) {
+                const index = p === '/' ? '/index.html' : `${p}/index.html`;
+                if (isFile(index))
+                    return index;
+            }
+            return undefined;
+        };
+        /** Apply the first matching `_redirects` rule (forced ones, or the others); false when none applies. */
+        const redirect = (forced) => {
+            for (const r of redirects) {
+                if (r.force !== forced)
+                    continue;
+                const rest = matchRedirect(r, vpath);
+                if (rest === undefined)
+                    continue;
+                const target = r.splat ? r.to.split(':splat').join(rest.split('/').map(encodeURIComponent).join('/')) : r.to;
+                if (r.status !== 200 && r.status !== 404) {
+                    finish(r.status, { location: target.includes('?') ? target : target + search, 'content-length': 0 }, undefined);
+                    return true;
+                }
+                // 200 (rewrite) and 404: serve the target path's file with that status.
+                const tq = target.indexOf('?');
+                const tpath = tq === -1 ? target : target.slice(0, tq);
+                const tsegs = safeSegments(tpath);
+                const served = tsegs ? resolve('/' + tsegs.join('/'), tpath.endsWith('/')) : undefined;
+                if (served === undefined)
+                    continue;
+                sendFile(r.status, served);
+                return true;
+            }
+            return false;
+        };
+        if (redirect(true))
+            return;
+        let served = resolve(vpath, trailingSlash);
+        if (served === undefined && !trailingSlash && tree.isDirectory(vpath)) {
+            const location = '/' + segs.map(encodeURIComponent).join('/') + '/' + search;
+            return finish(301, { location, 'content-length': 0 }, undefined);
+        }
+        if (served === undefined && redirect(false))
+            return;
+        if (served === undefined && options.spa && !/\.[^/.]+$/.test(segs[segs.length - 1] ?? '') && isFile('/index.html'))
+            served = '/index.html';
+        if (served !== undefined)
+            return sendFile(200, served);
+        if (isFile('/404.html'))
+            return sendFile(404, '/404.html');
+        page(404, NOT_FOUND_PAGE, custom);
+    };
+    const server = http.createServer(handler);
+    server.on('clientError', (_err, socket) => {
+        if (socket.writable)
+            socket.end('HTTP/1.1 400 Bad Request\r\nconnection: close\r\ncontent-length: 0\r\n\r\n');
+        else
+            socket.destroy();
+    });
+    return server;
+}
+/** Listen on host:port (port 0 = any free port); EADDRINUSE and friends become E_SERVER. */
+export function listen(server, host, port) {
+    return new Promise((resolve, reject) => {
+        const onError = (e) => {
+            const why = e.code === 'EADDRINUSE'
+                ? `port ${port} on ${host} is already in use`
+                : e.code === 'EACCES'
+                    ? `permission denied binding ${host}:${port}`
+                    : `cannot listen on ${host}:${port}: ${e.message}`;
+            reject(new SitefileError('E_SERVER', why, undefined, { cause: e }));
+        };
+        server.once('error', onError);
+        server.listen(port, host, () => {
+            server.off('error', onError);
+            resolve({ host, port: server.address().port });
+        });
+    });
+}
+export function closeServer(server) {
+    return new Promise((resolve) => {
+        server.close(() => resolve());
+        server.closeAllConnections();
+    });
+}
+export function formatUrl(host, port) {
+    const shown = host === '0.0.0.0' || host === '::' ? '127.0.0.1' : host;
+    return `http://${shown.includes(':') ? `[${shown}]` : shown}:${port}/`;
+}
+//# sourceMappingURL=server.js.map

package/lib/src/servers.d.ts

@@ -0,0 +1,71 @@
+import { Store } from './store.js';
+import { Tree } from './tree.js';
+/**
+ * Detached site servers ("containers"). One state file per server:
+ *
+ *   $SITEFILE_HOME/servers/<id>.json   state (this interface)
+ *   $SITEFILE_HOME/servers/<id>.log    stdout/stderr of the server process
+ *
+ * `serve -d` writes the state, spawns `node serve-worker.js <id>` detached, and the worker
+ * fills in `pid`, `host`, `port` and `ready` once it is listening. `servers` never trusts the
+ * file alone: a server is `running` only when its pid is alive AND the port answers with
+ * this server's `x-sitefile-server` header.
+ */
+export interface ServerState {
+    readonly id: string;
+    readonly name: string;
+    /** What the user asked to serve: the image reference as typed, or the directory. */
+    readonly image: string;
+    readonly source: {
+        readonly kind: 'image';
+        readonly imageId: string;
+    } | {
+        readonly kind: 'dir';
+        readonly path: string;
+    };
+    readonly spa: boolean;
+    /** The requested bind address (port 0 = pick a free port). */
+    readonly bind: {
+        readonly host: string;
+        readonly port: number;
+    };
+    readonly host: string;
+    readonly port: number;
+    readonly pid: number;
+    readonly started: string;
+    readonly logFile: string;
+    readonly ready: boolean;
+    readonly error?: string;
+}
+export interface ServerView extends ServerState {
+    readonly status: 'running' | 'exited';
+    readonly url: string;
+}
+export declare class ServerRegistry {
+    readonly store: Store;
+    readonly dir: string;
+    private constructor();
+    static open(store?: Store): Promise<ServerRegistry>;
+    statePath(id: string): string;
+    logPath(id: string): string;
+    read(id: string): Promise<ServerState | undefined>;
+    write(state: ServerState): Promise<void>;
+    update(id: string, patch: Partial<ServerState>): Promise<ServerState | undefined>;
+    remove(id: string): Promise<void>;
+    all(): Promise<ServerState[]>;
+    /** Find by exact ID, exact name, or unique ID prefix. */
+    find(key: string): Promise<ServerState>;
+    /** Allocate an ID and validate/choose the name (names are unique among all servers, running or not). */
+    allocate(name: string | undefined): Promise<{
+        id: string;
+        name: string;
+    }>;
+    view(s: ServerState): Promise<ServerView>;
+}
+export declare function pidAlive(pid: number): boolean;
+/** Alive AND answering on its port with its own id header (guards against pid and port reuse). */
+export declare function isRunning(s: ServerState): Promise<boolean>;
+/** Load a directory into a Tree through the sandboxed local reader; hidden files (except .well-known) are not served. */
+export declare function loadDirectoryTree(dir: string): Promise<Tree>;
+/** The tree a server state serves. */
+export declare function loadServedTree(store: Store, source: ServerState['source']): Promise<Tree>;

package/lib/src/servers.js

@@ -0,0 +1,139 @@
+import { randomBytes } from 'node:crypto';
+import { promises as fs } from 'node:fs';
+import http from 'node:http';
+import path from 'node:path';
+import { SitefileError } from './errors.js';
+import { LocalContext } from './resources/local.js';
+import { Store } from './store.js';
+import { Tree } from './tree.js';
+const NAME_RE = /^[A-Za-z0-9][A-Za-z0-9_.-]{0,62}$/;
+export class ServerRegistry {
+    store;
+    dir;
+    constructor(store) {
+        this.store = store;
+        this.dir = path.join(store.home, 'servers');
+    }
+    static async open(store) {
+        const reg = new ServerRegistry(store ?? (await Store.open()));
+        await fs.mkdir(reg.dir, { recursive: true, mode: 0o700 });
+        return reg;
+    }
+    statePath(id) {
+        if (!/^[0-9a-f]{12}$/.test(id))
+            throw new SitefileError('E_SERVER', `invalid server id '${id}'`);
+        return path.join(this.dir, `${id}.json`);
+    }
+    logPath(id) {
+        return path.join(this.dir, `${id}.log`);
+    }
+    async read(id) {
+        try {
+            return JSON.parse(await fs.readFile(this.statePath(id), 'utf8'));
+        }
+        catch (e) {
+            if (e.code === 'ENOENT' || e instanceof SyntaxError)
+                return undefined;
+            throw e;
+        }
+    }
+    async write(state) {
+        const dest = this.statePath(state.id);
+        const tmp = `${dest}.${randomBytes(4).toString('hex')}.tmp`;
+        await fs.writeFile(tmp, JSON.stringify(state, null, 2) + '\n', { mode: 0o600 });
+        await fs.rename(tmp, dest);
+    }
+    async update(id, patch) {
+        const cur = await this.read(id);
+        if (!cur)
+            return undefined;
+        const next = { ...cur, ...patch };
+        await this.write(next);
+        return next;
+    }
+    async remove(id) {
+        await fs.rm(this.statePath(id), { force: true });
+        await fs.rm(this.logPath(id), { force: true });
+    }
+    async all() {
+        const out = [];
+        for (const f of await fs.readdir(this.dir)) {
+            const m = /^([0-9a-f]{12})\.json$/.exec(f);
+            const s = m ? await this.read(m[1]) : undefined;
+            if (s)
+                out.push(s);
+        }
+        return out.sort((a, b) => (a.started < b.started ? -1 : a.started > b.started ? 1 : 0));
+    }
+    /** Find by exact ID, exact name, or unique ID prefix. */
+    async find(key) {
+        const all = await this.all();
+        const hit = all.find((s) => s.id === key) ?? all.find((s) => s.name === key);
+        if (hit)
+            return hit;
+        const pre = key.length >= 3 ? all.filter((s) => s.id.startsWith(key)) : [];
+        if (pre.length === 1)
+            return pre[0];
+        if (pre.length > 1)
+            throw new SitefileError('E_SERVER', `ambiguous server '${key}' matches ${pre.length} servers`);
+        throw new SitefileError('E_NOT_FOUND', `no such server: ${key}`);
+    }
+    /** Allocate an ID and validate/choose the name (names are unique among all servers, running or not). */
+    async allocate(name) {
+        const all = await this.all();
+        if (name !== undefined) {
+            if (!NAME_RE.test(name))
+                throw new SitefileError('E_USAGE', `invalid server name '${name}' (letters, digits, '_', '.', '-')`);
+            if (all.some((s) => s.name === name))
+                throw new SitefileError('E_SERVER', `a server named '${name}' already exists; remove it with "sitefile rm ${name}"`);
+        }
+        const id = randomBytes(6).toString('hex');
+        return { id, name: name ?? `site-${id.slice(0, 6)}` };
+    }
+    async view(s) {
+        const running = await isRunning(s);
+        return { ...s, status: running ? 'running' : 'exited', url: s.ready ? urlOf(s) : '' };
+    }
+}
+function urlOf(s) {
+    const shown = s.host === '0.0.0.0' ? '127.0.0.1' : s.host === '::' ? '::1' : s.host;
+    return `http://${shown.includes(':') ? `[${shown}]` : shown}:${s.port}/`;
+}
+export function pidAlive(pid) {
+    if (!Number.isInteger(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (e) {
+        return e.code === 'EPERM';
+    }
+}
+/** Alive AND answering on its port with its own id header (guards against pid and port reuse). */
+export async function isRunning(s) {
+    if (!s.ready || !pidAlive(s.pid))
+        return false;
+    const host = s.host === '0.0.0.0' ? '127.0.0.1' : s.host === '::' ? '::1' : s.host;
+    return new Promise((resolve) => {
+        const req = http.request({ host, port: s.port, method: 'HEAD', path: '/', headers: { 'x-sitefile-probe': s.id }, timeout: 1500, agent: false }, (res) => {
+            res.resume();
+            resolve(res.headers['x-sitefile-server'] === s.id);
+        });
+        req.on('timeout', () => req.destroy());
+        req.on('error', () => resolve(false));
+        req.end();
+    });
+}
+/** Load a directory into a Tree through the sandboxed local reader; hidden files (except .well-known) are not served. */
+export async function loadDirectoryTree(dir) {
+    const ctx = await LocalContext.open(dir, { sitefileignore: false });
+    const { tree } = await ctx.readTree('', 'serve');
+    const visible = tree.entries().filter(([p]) => p.split('/').every((seg) => !seg.startsWith('.') || seg === '' || seg === '.well-known'));
+    return Tree.fromFiles(visible);
+}
+/** The tree a server state serves. */
+export async function loadServedTree(store, source) {
+    return source.kind === 'image' ? store.loadTree(source.imageId) : loadDirectoryTree(source.path);
+}
+//# sourceMappingURL=servers.js.map