@design.estate/wcctools 6.2.0 → 7.0.0

package/dist_ts/classes.devserver.js

@@ -2,6 +2,8 @@ import * as plugins from './plugins.js';
 import * as paths from './paths.js';
 import { commitinfo } from './00_commitinfo_data.js';
 import { WccDevApi } from './classes.devapi.js';
+import { WccHostPolicy, defaultListenHost, formatUrlHost } from './classes.hostpolicy.js';
+import { WccCaptureService } from './capture/index.js';
 import { loadShellContent, shellPathPrefix } from './shellcontent.js';
 /** tswatch's default port and serve directory, used when the configuration names none. */
 const defaultPort = 3002;
@@ -11,6 +13,7 @@ const securityHeaders = {
     crossOriginOpenerPolicy: 'same-origin',
     crossOriginEmbedderPolicy: 'require-corp',
 };
+/** Every surface takes every hostname: the server-wide Host admission refuses the ones it does not serve. */
 const acceptAnyHostname = () => true;
 /**
  * `wcctools dev`: bundles the catalog of a project with tswatch, as its `@git.zone/tswatch`
@@ -19,7 +22,12 @@ const acceptAnyHostname = () => true;
  * - the shell on `/wcctools/` (`/` redirects there) and its routes `/wcctools-route/...`,
  * - the typed API on `/wcctools/typedrequest`, including the bundles' status,
  * - the catalog's preview document and bundle from the tswatch serve directory on every other
- *   path, with live reload that reloads only the preview document.
+ *   path, with live reload that reloads only the preview document,
+ * - captures of single demos in a headless browser (`capture`, also on the typed API).
+ *
+ * It listens on loopback unless told otherwise and admits requests as its `WccHostPolicy`
+ * describes: only the hosts it serves, and state-changing requests and WebSockets only from its
+ * own origin.
  *
  * The server owns no process lifecycle: while it runs, a process shutdown through smartexit's
  * `ProcessLifecycle` stops it. The entry point installs that lifecycle with
@@ -29,6 +37,10 @@ export class WccDevServer {
     options;
     /** The typed API on `/wcctools/typedrequest`; register further handlers before `start()`. */
     api = new WccDevApi();
+    /** Screenshots and interaction captures of the served catalog; available while the server runs. */
+    capture;
+    /** Who may talk to the server: the hosts it answers and the origin of its requests. */
+    hostPolicy;
     /** The project directory everything resolves against. */
     cwd;
     /** The project's tswatch configuration, or the `element` preset; read once, on construction. */
@@ -48,6 +60,9 @@ export class WccDevServer {
         const configHandler = new plugins.tswatch.ConfigHandler(this.cwd);
         this.config = configHandler.loadConfig() ?? this.getElementPreset(configHandler);
         this.tsWatch = new plugins.tswatch.TsWatch({ ...this.config, server: { enabled: false } }, { cwd: this.cwd });
+        this.hostPolicy = new WccHostPolicy({ listenHost: options.host ?? defaultListenHost, allowedHosts: options.allowedHosts });
+        this.capture = new WccCaptureService(this.api.bundleStatus);
+        this.capture.addTypedHandlers(this.api.typedrouter);
     }
     /**
      * The shutdown deadline the server needs, tswatch's: the entry point installs smartexit's
@@ -113,9 +128,12 @@ export class WccDevServer {
         // requests until the server stops listening are refused too: the shell backs off
         this.api.bundleStatus.close();
         try {
+            // Captures end and the capture browser closes before the server stops answering its pages
+            await this.capture.close();
             await typedServer?.stop();
         }
         finally {
+            this.hostPolicy.setPort(null);
             try {
                 await this.tsWatch.stop();
             }
@@ -135,7 +153,15 @@ export class WccDevServer {
             projectName: await this.readProjectName(),
         });
         const surfaces = [await this.createShellSurface(), this.createPreviewSurface(serveDir)];
-        const typedServer = new plugins.typedserver.TypedServer({ cors: false, port, surfaces });
+        const typedServer = new plugins.typedserver.TypedServer({
+            cors: false,
+            port,
+            listenHostname: this.hostPolicy.listenHost,
+            // Requests and WebSocket upgrades for a Host the server does not serve are refused
+            requestAdmission: this.hostPolicy.admitHost,
+            websocketAdmission: this.hostPolicy.admitHost,
+            surfaces,
+        });
         this.typedServer = typedServer;
         this.api.bundleStatus.open();
         const bundleStatus = this.api.bundleStatus;
@@ -144,7 +170,14 @@ export class WccDevServer {
         await this.tsWatch.start();
         await typedServer.start();
         const boundPort = typedServer.listeningPort ?? port;
-        return { port: boundPort, url: `http://localhost:${boundPort}${shellPathPrefix}/` };
+        this.hostPolicy.setPort(boundPort);
+        this.capture.open(`http://${formatUrlHost(this.hostPolicy.getLocalHost())}:${boundPort}`);
+        return {
+            port: boundPort,
+            url: `http://${formatUrlHost(this.hostPolicy.getDisplayHost())}:${boundPort}${shellPathPrefix}/`,
+            host: this.hostPolicy.listenHost,
+            allowedHosts: [...this.hostPolicy.allowedHostnames],
+        };
     }
     getElementPreset(configHandlerArg) {
         const preset = configHandlerArg.getPreset('element');
@@ -154,14 +187,8 @@ export class WccDevServer {
         return preset;
     }
     /**
-     * The shell: the prebuilt shell bundle and the typed API.
-     *
-     * Seam for side-effecting APIs (assistant, capture, standards fixes): before any handler with
-     * side effects is registered here, the server binds to localhost by default (another interface
-     * only on explicit request), validates the Host header against the addresses it serves instead
-     * of accepting any hostname, and admits typedsocket connections and typed requests only from the
-     * shell's own origin (a `websocketAdmission`/`requestAdmission`), keeping surface mode's strict
-     * authority validation. Until then every handler here is read-only.
+     * The shell: the prebuilt shell bundle and the typed API, whose requests (captures among them)
+     * are admitted only from the server's own origin.
      */
     async createShellSurface() {
         return {
@@ -174,6 +201,8 @@ export class WccDevServer {
             spaFallback: true,
             httpTypedRouter: this.api.typedrouter,
             typedRequestPath: `${shellPathPrefix}/typedrequest`,
+            requestAdmission: this.hostPolicy.admitRequestOrigin,
+            websocketAdmission: this.hostPolicy.admitWebsocketOrigin,
             noCache: true,
             securityHeaders,
         };
@@ -196,8 +225,10 @@ export class WccDevServer {
             watch: true,
             // Lets the reload client get pushed changes instead of polling
             websocketTypedRouter: new plugins.typedrequest.TypedRouter(),
-            // As tswatch serves catalogs
-            cors: true,
+            requestAdmission: this.hostPolicy.admitRequestOrigin,
+            websocketAdmission: this.hostPolicy.admitWebsocketOrigin,
+            // Shell and preview share one origin, so no other origin may read the catalog
+            cors: false,
             httpHandler: async (contextArg) => {
                 if (contextArg.path === '/' && (contextArg.method === 'GET' || contextArg.method === 'HEAD')) {
                     return new Response(null, { status: 302, headers: { Location: `${shellPathPrefix}/` } });
@@ -213,4 +244,4 @@ export class WccDevServer {
         return packageJson.name ?? plugins.path.basename(this.cwd);
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.devserver.js","sourceRoot":"","sources":["../../ts/classes.devserver.ts"],"names":[],"mappings":"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"}

package/dist_ts/classes.hostpolicy.d.ts

@@ -0,0 +1,63 @@
+import * as plugins from './plugins.js';
+type TRequestContext = plugins.typedserver.IRequestContext;
+type TAdmissionResult = plugins.typedserver.TRequestAdmissionResult;
+/** The interface address `wcctools dev` listens on unless told otherwise. */
+export declare const defaultListenHost = "127.0.0.1";
+/** Canonical form of a hostname: lower case, IPv6 without brackets, no trailing dot. */
+export declare const normalizeHostname: (hostnameArg: string) => string;
+/** Whether the address is the wildcard address of all interfaces. */
+export declare const isWildcardHost: (hostArg: string) => boolean;
+/** Whether a peer address is a loopback address (IPv4, IPv6 or IPv4-mapped IPv6). */
+export declare const isLoopbackAddress: (addressArg: string) => boolean;
+/** A hostname as it appears in a URL: IPv6 addresses in brackets. */
+export declare const formatUrlHost: (hostnameArg: string) => string;
+/** An invalid `--host` or `--allowed-host` value. */
+export declare class WccHostPolicyError extends Error {
+    constructor(messageArg: string);
+}
+export interface IWccHostPolicyOptions {
+    /** The interface address the server listens on. */
+    listenHost: string;
+    /** Further hostnames or addresses the server answers (`--allowed-host`). */
+    allowedHosts?: readonly string[];
+}
+/**
+ * Who may talk to a `wcctools dev` server. The server listens on loopback unless told otherwise
+ * and answers only the hostnames it serves: the loopback names, the address it listens on, the
+ * machine's interface addresses when it listens on all of them, and the hosts allowed explicitly.
+ * Every other Host is refused, which defeats DNS rebinding. Requests that can change state
+ * (any method but GET, HEAD and OPTIONS) and WebSocket connections are further admitted only from
+ * the server's own origin, so other web pages cannot drive the API; a request without an Origin
+ * is admitted only from a loopback peer (local tools, such as the CLI and tests).
+ */
+export declare class WccHostPolicy {
+    /** The canonical hostnames the server answers. */
+    readonly allowedHostnames: ReadonlySet<string>;
+    readonly listenHost: string;
+    private port;
+    constructor(optionsArg: IWccHostPolicyOptions);
+    /** A hostname or address, as a URL would carry it; anything else is refused. */
+    private static parseHost;
+    /** Every address of the machine's network interfaces. */
+    private static getInterfaceAddresses;
+    /** The port the server listens on, once it does: origins are compared against it. */
+    setPort(portArg: number | null): void;
+    /**
+     * The host the server's own tools reach it on: the loopback address when it listens on all
+     * interfaces or on loopback, otherwise the address it listens on.
+     */
+    getLocalHost(): string;
+    /** The host shown to the user: `localhost` for a loopback or all-interface server. */
+    getDisplayHost(): string;
+    /** Server-wide HTTP and WebSocket admission: the Host must be one the server answers. */
+    readonly admitHost: (contextArg: TRequestContext) => TAdmissionResult;
+    /** Surface HTTP admission: a request that can change state must come from the server's origin. */
+    readonly admitRequestOrigin: (contextArg: TRequestContext) => TAdmissionResult;
+    /** Surface WebSocket admission: a connection must come from the server's origin. */
+    readonly admitWebsocketOrigin: (contextArg: TRequestContext) => TAdmissionResult;
+    /** Whether an Origin header names this server: http, an allowed host and the server's port. */
+    isOwnOrigin(originArg: string): boolean;
+    private admitOrigin;
+    private refuse;
+}
+export {};

package/dist_ts/classes.hostpolicy.js

@@ -0,0 +1,171 @@
+import * as plugins from './plugins.js';
+/** The interface address `wcctools dev` listens on unless told otherwise. */
+export const defaultListenHost = '127.0.0.1';
+/** The hostnames every dev server answers: the loopback names. */
+const loopbackHostnames = ['localhost', '127.0.0.1', '::1'];
+const wildcardHosts = new Set(['0.0.0.0', '::']);
+/** Methods that never change state, which the Origin check leaves to the Host check alone. */
+const safeMethods = new Set(['GET', 'HEAD', 'OPTIONS']);
+/** Canonical form of a hostname: lower case, IPv6 without brackets, no trailing dot. */
+export const normalizeHostname = (hostnameArg) => {
+    let hostname = hostnameArg.trim().toLowerCase();
+    if (hostname.startsWith('[') && hostname.endsWith(']')) {
+        hostname = hostname.slice(1, -1);
+    }
+    if (hostname.endsWith('.') && hostname.length > 1) {
+        hostname = hostname.slice(0, -1);
+    }
+    return hostname;
+};
+/** Whether the address is the wildcard address of all interfaces. */
+export const isWildcardHost = (hostArg) => wildcardHosts.has(normalizeHostname(hostArg));
+/** Whether a peer address is a loopback address (IPv4, IPv6 or IPv4-mapped IPv6). */
+export const isLoopbackAddress = (addressArg) => {
+    const address = normalizeHostname(addressArg);
+    return address === '::1' || address.startsWith('127.') || address.startsWith('::ffff:127.');
+};
+/** A hostname as it appears in a URL: IPv6 addresses in brackets. */
+export const formatUrlHost = (hostnameArg) => {
+    return hostnameArg.includes(':') ? `[${hostnameArg}]` : hostnameArg;
+};
+/** An invalid `--host` or `--allowed-host` value. */
+export class WccHostPolicyError extends Error {
+    constructor(messageArg) {
+        super(messageArg);
+        this.name = 'WccHostPolicyError';
+    }
+}
+/**
+ * Who may talk to a `wcctools dev` server. The server listens on loopback unless told otherwise
+ * and answers only the hostnames it serves: the loopback names, the address it listens on, the
+ * machine's interface addresses when it listens on all of them, and the hosts allowed explicitly.
+ * Every other Host is refused, which defeats DNS rebinding. Requests that can change state
+ * (any method but GET, HEAD and OPTIONS) and WebSocket connections are further admitted only from
+ * the server's own origin, so other web pages cannot drive the API; a request without an Origin
+ * is admitted only from a loopback peer (local tools, such as the CLI and tests).
+ */
+export class WccHostPolicy {
+    /** The canonical hostnames the server answers. */
+    allowedHostnames;
+    listenHost;
+    port = null;
+    constructor(optionsArg) {
+        this.listenHost = WccHostPolicy.parseHost(optionsArg.listenHost);
+        const hostnames = new Set(loopbackHostnames);
+        if (isWildcardHost(this.listenHost)) {
+            for (const address of WccHostPolicy.getInterfaceAddresses()) {
+                hostnames.add(address);
+            }
+        }
+        else {
+            hostnames.add(this.listenHost);
+        }
+        for (const host of optionsArg.allowedHosts ?? []) {
+            hostnames.add(WccHostPolicy.parseHost(host));
+        }
+        this.allowedHostnames = hostnames;
+    }
+    /** A hostname or address, as a URL would carry it; anything else is refused. */
+    static parseHost(hostArg) {
+        const hostname = normalizeHostname(hostArg);
+        let parsed = null;
+        try {
+            parsed = normalizeHostname(new URL(`http://${formatUrlHost(hostname)}/`).hostname);
+        }
+        catch {
+            parsed = null;
+        }
+        if (!hostname || parsed !== hostname) {
+            throw new WccHostPolicyError(`wcctools: "${hostArg}" is not a hostname or address.`);
+        }
+        return hostname;
+    }
+    /** Every address of the machine's network interfaces. */
+    static getInterfaceAddresses() {
+        const addresses = [];
+        for (const interfaceAddresses of Object.values(plugins.os.networkInterfaces())) {
+            for (const interfaceAddress of interfaceAddresses ?? []) {
+                addresses.push(normalizeHostname(interfaceAddress.address));
+            }
+        }
+        return addresses;
+    }
+    /** The port the server listens on, once it does: origins are compared against it. */
+    setPort(portArg) {
+        this.port = portArg;
+    }
+    /**
+     * The host the server's own tools reach it on: the loopback address when it listens on all
+     * interfaces or on loopback, otherwise the address it listens on.
+     */
+    getLocalHost() {
+        if (isWildcardHost(this.listenHost) || isLoopbackAddress(this.listenHost)) {
+            return '127.0.0.1';
+        }
+        return this.listenHost;
+    }
+    /** The host shown to the user: `localhost` for a loopback or all-interface server. */
+    getDisplayHost() {
+        if (isWildcardHost(this.listenHost) || isLoopbackAddress(this.listenHost) || this.listenHost === 'localhost') {
+            return 'localhost';
+        }
+        return this.listenHost;
+    }
+    /** Server-wide HTTP and WebSocket admission: the Host must be one the server answers. */
+    admitHost = (contextArg) => {
+        const hostname = normalizeHostname(contextArg.url.hostname);
+        if (this.allowedHostnames.has(hostname)) {
+            return true;
+        }
+        return this.refuse(`wcctools: the dev server does not answer the host "${hostname}". Open it on localhost, or restart it with --allowed-host ${hostname}.`);
+    };
+    /** Surface HTTP admission: a request that can change state must come from the server's origin. */
+    admitRequestOrigin = (contextArg) => {
+        if (safeMethods.has(contextArg.method)) {
+            return true;
+        }
+        return this.admitOrigin(contextArg);
+    };
+    /** Surface WebSocket admission: a connection must come from the server's origin. */
+    admitWebsocketOrigin = (contextArg) => {
+        return this.admitOrigin(contextArg);
+    };
+    /** Whether an Origin header names this server: http, an allowed host and the server's port. */
+    isOwnOrigin(originArg) {
+        if (this.port === null) {
+            return false;
+        }
+        let origin;
+        try {
+            origin = new URL(originArg);
+        }
+        catch {
+            return false;
+        }
+        const port = origin.port === '' ? 80 : Number(origin.port);
+        return origin.protocol === 'http:'
+            && port === this.port
+            && this.allowedHostnames.has(normalizeHostname(origin.hostname));
+    }
+    admitOrigin(contextArg) {
+        const origin = contextArg.headers.get('origin');
+        if (origin === null) {
+            const peer = contextArg.connectionInfo?.remoteAddr ?? 'unknown';
+            if (isLoopbackAddress(peer)) {
+                return true;
+            }
+            return this.refuse('wcctools: requests without an Origin are admitted only from this machine.');
+        }
+        if (this.isOwnOrigin(origin)) {
+            return true;
+        }
+        return this.refuse(`wcctools: requests from the origin "${origin}" are not admitted.`);
+    }
+    refuse(messageArg) {
+        return new Response(`${messageArg}\n`, {
+            status: 403,
+            headers: { 'Content-Type': 'text/plain; charset=utf-8' },
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/cli.js

@@ -1,6 +1,9 @@
 import * as plugins from './plugins.js';
 import { commitinfo } from './00_commitinfo_data.js';
 import { WccDevServer } from './classes.devserver.js';
+import { WccHostPolicyError } from './classes.hostpolicy.js';
+import { WccCaptureRequestError } from './capture/index.js';
+import { registerScreenshotCommand } from './cli.screenshot.js';
 import { StandardConfigError, StandardUsageError, registerStandardCommands } from './standards/index.js';
 /**
  * Registers the wcctools commands on the given console.
@@ -19,15 +22,32 @@ export const registerCommands = (out) => {
                 type: 'number',
                 description: 'Port to listen on (0 picks a free port); overrides the tswatch configuration',
             },
+            host: {
+                type: 'string',
+                description: 'Interface address to listen on (default 127.0.0.1, this machine only; 0.0.0.0 for every interface)',
+            },
+            allowedHost: {
+                type: 'strings',
+                description: 'A further hostname or address the server answers, besides localhost and the listen address (repeatable)',
+            },
         },
     }, async ({ options }) => {
-        const devServer = new WccDevServer({ port: options.port, cwd: process.cwd() });
+        const devServer = new WccDevServer({
+            port: options.port,
+            cwd: process.cwd(),
+            host: options.host,
+            allowedHosts: options.allowedHost,
+        });
         // The entry point owns process signals: SIGINT and SIGTERM run every registered cleanup, the
         // dev server's stop among them, once within tswatch's shutdown deadline, then exit.
         plugins.smartexit.ProcessLifecycle.install({ shutdownTimeoutMs: devServer.getShutdownTimeoutMs() });
         const address = await devServer.start();
         await out.log(`wcctools dev: ${address.url}`);
+        if (address.host !== '127.0.0.1' && address.host !== '::1' && address.host !== 'localhost') {
+            await out.log(`wcctools dev: listening on ${address.host}, answering the hosts ${address.allowedHosts.join(', ')}`);
+        }
     });
+    registerScreenshotCommand(out);
     registerStandardCommands(out);
     out.cli.default({}, async () => {
         await out.log(out.cli.renderHelp());
@@ -44,11 +64,13 @@ export const runCli = async () => {
         // Configuration and usage errors exit with 2, every other failure with 1.
         const usageError = error instanceof plugins.smartconsole.CliUsageError
             || error instanceof StandardConfigError
-            || error instanceof StandardUsageError;
+            || error instanceof StandardUsageError
+            || error instanceof WccCaptureRequestError
+            || error instanceof WccHostPolicyError;
         process.exitCode = usageError ? 2 : 1;
     }
     finally {
         await out.dispose();
     }
 };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xpLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vdHMvY2xpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxPQUFPLE1BQU0sY0FBYyxDQUFDO0FBQ3hDLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQztBQUNyRCxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFDdEQsT0FBTyxFQUFFLG1CQUFtQixFQUFFLGtCQUFrQixFQUFFLHdCQUF3QixFQUFFLE1BQU0sc0JBQXNCLENBQUM7QUFFekc7O0dBRUc7QUFDSCxNQUFNLENBQUMsTUFBTSxnQkFBZ0IsR0FBRyxDQUFDLEdBQXNDLEVBQVEsRUFBRTtJQUMvRSxHQUFHLENBQUMsR0FBRyxDQUFDLFNBQVMsQ0FBQztRQUNoQixJQUFJLEVBQUUsVUFBVTtRQUNoQixPQUFPLEVBQUUsVUFBVSxDQUFDLE9BQU87UUFDM0IsV0FBVyxFQUFFLHVEQUF1RDtLQUNyRSxDQUFDLENBQUM7SUFFSCxHQUFHLENBQUMsR0FBRyxDQUFDLE9BQU8sQ0FBQztRQUNkLElBQUksRUFBRSxLQUFLO1FBQ1gsV0FBVyxFQUFFLHdFQUF3RTtRQUNyRixPQUFPLEVBQUU7WUFDUCxJQUFJLEVBQUU7Z0JBQ0osSUFBSSxFQUFFLFFBQVE7Z0JBQ2QsV0FBVyxFQUFFLDhFQUE4RTthQUM1RjtTQUNGO0tBQ0YsRUFBRSxLQUFLLEVBQUUsRUFBRSxPQUFPLEVBQUUsRUFBRSxFQUFFO1FBQ3ZCLE1BQU0sU0FBUyxHQUFHLElBQUksWUFBWSxDQUFDLEVBQUUsSUFBSSxFQUFFLE9BQU8sQ0FBQyxJQUFJLEVBQUUsR0FBRyxFQUFFLE9BQU8sQ0FBQyxHQUFHLEVBQUUsRUFBRSxDQUFDLENBQUM7UUFDL0UsNkZBQTZGO1FBQzdGLG9GQUFvRjtRQUNwRixPQUFPLENBQUMsU0FBUyxDQUFDLGdCQUFnQixDQUFDLE9BQU8sQ0FBQyxFQUFFLGlCQUFpQixFQUFFLFNBQVMsQ0FBQyxvQkFBb0IsRUFBRSxFQUFFLENBQUMsQ0FBQztRQUNwRyxNQUFNLE9BQU8sR0FBRyxNQUFNLFNBQVMsQ0FBQyxLQUFLLEVBQUUsQ0FBQztRQUN4QyxNQUFNLEdBQUcsQ0FBQyxHQUFHLENBQUMsaUJBQWlCLE9BQU8sQ0FBQyxHQUFHLEVBQUUsQ0FBQyxDQUFDO0lBQ2hELENBQUMsQ0FBQyxDQUFDO0lBRUgsd0JBQXdCLENBQUMsR0FBRyxDQUFDLENBQUM7SUFFOUIsR0FBRyxDQUFDLEdBQUcsQ0FBQyxPQUFPLENBQUMsRUFBRSxFQUFFLEtBQUssSUFBSSxFQUFFO1FBQzdCLE1BQU0sR0FBRyxDQUFDLEdBQUcsQ0FBQyxHQUFHLENBQUMsR0FBRyxDQUFDLFVBQVUsRUFBRSxDQUFDLENBQUM7SUFDdEMsQ0FBQyxDQUFDLENBQUM7QUFDTCxDQUFDLENBQUM7QUFFRixNQUFNLENBQUMsTUFBTSxNQUFNLEdBQUcsS0FBSyxJQUFJLEVBQUU7SUFDL0IsTUFBTSxHQUFHLEdBQUcsSUFBSSxPQUFPLENBQUMsWUFBWSxDQUFDLFlBQVksRUFBRSxDQUFDO0lBQ3BELElBQUksQ0FBQztRQUNILGdCQUFnQixDQUFDLEdBQUcsQ0FBQyxDQUFDO1FBQ3RCLE1BQU0sR0FBRyxDQUFDLEdBQUcsQ0FBQyxHQUFHLEVBQUUsQ0FBQztJQUN0QixDQUFDO0lBQUMsT0FBTyxLQUFLLEVBQUUsQ0FBQztRQUNmLE1BQU0sR0FBRyxDQUFDLEtBQUssQ0FBQyxLQUFLLFlBQVksS0FBSyxDQUFDLENBQUMsQ0FBQyxLQUFLLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQyxNQUFNLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQztRQUN4RSwwRUFBMEU7UUFDMUUsTUFBTSxVQUFVLEdBQUcsS0FBSyxZQUFZLE9BQU8sQ0FBQyxZQUFZLENBQUMsYUFBYTtlQUNqRSxLQUFLLFlBQVksbUJBQW1CO2VBQ3BDLEtBQUssWUFBWSxrQkFBa0IsQ0FBQztRQUN6QyxPQUFPLENBQUMsUUFBUSxHQUFHLFVBQVUsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUM7SUFDeEMsQ0FBQztZQUFTLENBQUM7UUFDVCxNQUFNLEdBQUcsQ0FBQyxPQUFPLEVBQUUsQ0FBQztJQUN0QixDQUFDO0FBQ0gsQ0FBQyxDQUFDIn0=
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/cli.screenshot.d.ts

@@ -0,0 +1,6 @@
+import * as plugins from './plugins.js';
+/**
+ * `wcctools screenshot`: bundles the catalog of the working directory, serves it on a free
+ * loopback port, screenshots one demo in a headless browser, writes the image and stops.
+ */
+export declare const registerScreenshotCommand: (out: plugins.smartconsole.SmartConsole) => void;

package/dist_ts/cli.screenshot.js

@@ -0,0 +1,89 @@
+import * as plugins from './plugins.js';
+import { WccDevServer } from './classes.devserver.js';
+import { WccCaptureRequestError, captureViewportWidths, resolveScreenshotRequest } from './capture/index.js';
+/** Reads `<item>` or `<section>/<item>`. */
+const parseSubject = (argsArg, demoArg) => {
+    if (argsArg.length !== 1 || argsArg[0].trim() === '') {
+        throw new WccCaptureRequestError('wcctools screenshot: name one catalog entry, as <item> or <section>/<item>.');
+    }
+    const [subject] = argsArg;
+    const slash = subject.indexOf('/');
+    const named = slash === -1
+        ? { itemName: subject }
+        : { sectionName: subject.slice(0, slash), itemName: subject.slice(slash + 1) };
+    return demoArg === undefined ? named : { ...named, demoIndex: demoArg };
+};
+/** Reads a named viewport or a width in pixels. */
+const parseViewport = (valueArg) => {
+    if (valueArg === undefined) {
+        return undefined;
+    }
+    if (Object.hasOwn(captureViewportWidths, valueArg)) {
+        return valueArg;
+    }
+    if (/^\d+$/.test(valueArg)) {
+        return Number(valueArg);
+    }
+    throw new WccCaptureRequestError(`wcctools screenshot: --viewport must be one of ${Object.keys(captureViewportWidths).join(', ')} or a width in pixels.`);
+};
+/** The image format the output file's extension names. */
+const formatForFile = (fileArg) => {
+    const extension = plugins.path.extname(fileArg).toLowerCase();
+    if (extension === '.png') {
+        return 'png';
+    }
+    if (extension === '.jpg' || extension === '.jpeg') {
+        return 'jpeg';
+    }
+    throw new WccCaptureRequestError('wcctools screenshot: --out must name a .png, .jpg or .jpeg file.');
+};
+/**
+ * `wcctools screenshot`: bundles the catalog of the working directory, serves it on a free
+ * loopback port, screenshots one demo in a headless browser, writes the image and stops.
+ */
+export const registerScreenshotCommand = (out) => {
+    out.cli.command({
+        name: 'screenshot',
+        description: 'Screenshot one demo of the catalog in a headless browser: wcctools screenshot <item | section/item> --out <file.png>',
+        options: {
+            out: { type: 'string', required: true, description: 'The image file to write; .png, .jpg or .jpeg' },
+            demo: { type: 'number', description: 'The demo to render, counted from 0 as in the shell URL (default 0)' },
+            viewport: { type: 'string', description: `The width: ${Object.entries(captureViewportWidths).map(([nameArg, widthArg]) => `${nameArg} (${widthArg})`).join(', ')} or pixels (default desktop)` },
+            height: { type: 'number', description: 'The height of the preview window in pixels (default 800)' },
+            theme: { type: 'string', description: 'dark or bright (default dark)' },
+            framing: { type: 'string', description: 'element, viewport or fullpage (default element; fullpage for pages)' },
+            scale: { type: 'number', description: 'Device pixel ratio, 1 or 2 (default 1)' },
+            quality: { type: 'number', description: 'JPEG quality from 1 to 100 (default 80)' },
+        },
+    }, async ({ args, options }) => {
+        const format = formatForFile(options.out);
+        const request = {
+            subject: parseSubject(args, options.demo),
+            viewport: parseViewport(options.viewport),
+            height: options.height,
+            theme: options.theme,
+            framing: options.framing,
+            scale: options.scale,
+            format,
+            quality: options.quality,
+        };
+        // Invalid options are refused before anything is bundled
+        resolveScreenshotRequest(request);
+        const outFile = plugins.path.resolve(options.out);
+        const devServer = new WccDevServer({ port: 0, cwd: process.cwd() });
+        // As for `wcctools dev`: SIGINT and SIGTERM stop the server and the capture browser once
+        plugins.smartexit.ProcessLifecycle.install({ shutdownTimeoutMs: devServer.getShutdownTimeoutMs() });
+        let result;
+        try {
+            await devServer.start();
+            result = await devServer.capture.captureScreenshot(request);
+        }
+        finally {
+            await devServer.stop();
+        }
+        await plugins.fs.writeFile(outFile, Buffer.from(result.image.dataBase64, 'base64'));
+        const { selection, image } = result;
+        await out.log(`wcctools screenshot: wrote ${outFile} (${selection.sectionName}/${selection.itemName} demo ${selection.demoIndex}, ${result.framing}, ${image.width}×${image.height}${result.truncated ? ', cut at the maximum height' : ''})`);
+    });
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xpLnNjcmVlbnNob3QuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9jbGkuc2NyZWVuc2hvdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssT0FBTyxNQUFNLGNBQWMsQ0FBQztBQUN4QyxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFDdEQsT0FBTyxFQUFFLHNCQUFzQixFQUFFLHFCQUFxQixFQUFFLHdCQUF3QixFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFFN0csNENBQTRDO0FBQzVDLE1BQU0sWUFBWSxHQUFHLENBQUMsT0FBMEIsRUFBRSxPQUEyQixFQUF5QyxFQUFFO0lBQ3RILElBQUksT0FBTyxDQUFDLE1BQU0sS0FBSyxDQUFDLElBQUksT0FBTyxDQUFDLENBQUMsQ0FBQyxDQUFDLElBQUksRUFBRSxLQUFLLEVBQUUsRUFBRSxDQUFDO1FBQ3JELE1BQU0sSUFBSSxzQkFBc0IsQ0FBQyw2RUFBNkUsQ0FBQyxDQUFDO0lBQ2xILENBQUM7SUFDRCxNQUFNLENBQUMsT0FBTyxDQUFDLEdBQUcsT0FBTyxDQUFDO0lBQzFCLE1BQU0sS0FBSyxHQUFHLE9BQU8sQ0FBQyxPQUFPLENBQUMsR0FBRyxDQUFDLENBQUM7SUFDbkMsTUFBTSxLQUFLLEdBQTBDLEtBQUssS0FBSyxDQUFDLENBQUM7UUFDL0QsQ0FBQyxDQUFDLEVBQUUsUUFBUSxFQUFFLE9BQU8sRUFBRTtRQUN2QixDQUFDLENBQUMsRUFBRSxXQUFXLEVBQUUsT0FBTyxDQUFDLEtBQUssQ0FBQyxDQUFDLEVBQUUsS0FBSyxDQUFDLEVBQUUsUUFBUSxFQUFFLE9BQU8sQ0FBQyxLQUFLLENBQUMsS0FBSyxHQUFHLENBQUMsQ0FBQyxFQUFFLENBQUM7SUFDakYsT0FBTyxPQUFPLEtBQUssU0FBUyxDQUFDLENBQUMsQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDLEVBQUUsR0FBRyxLQUFLLEVBQUUsU0FBUyxFQUFFLE9BQU8sRUFBRSxDQUFDO0FBQzFFLENBQUMsQ0FBQztBQUVGLG1EQUFtRDtBQUNuRCxNQUFNLGFBQWEsR0FBRyxDQUFDLFFBQTRCLEVBQXNELEVBQUU7SUFDekcsSUFBSSxRQUFRLEtBQUssU0FBUyxFQUFFLENBQUM7UUFDM0IsT0FBTyxTQUFTLENBQUM7SUFDbkIsQ0FBQztJQUNELElBQUksTUFBTSxDQUFDLE1BQU0sQ0FBQyxxQkFBcUIsRUFBRSxRQUFRLENBQUMsRUFBRSxDQUFDO1FBQ25ELE9BQU8sUUFBd0QsQ0FBQztJQUNsRSxDQUFDO0lBQ0QsSUFBSSxPQUFPLENBQUMsSUFBSSxDQUFDLFFBQVEsQ0FBQyxFQUFFLENBQUM7UUFDM0IsT0FBTyxNQUFNLENBQUMsUUFBUSxDQUFDLENBQUM7SUFDMUIsQ0FBQztJQUNELE1BQU0sSUFBSSxzQkFBc0IsQ0FDOUIsa0RBQWtELE1BQU0sQ0FBQyxJQUFJLENBQUMscUJBQXFCLENBQUMsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLHdCQUF3QixDQUN4SCxDQUFDO0FBQ0osQ0FBQyxDQUFDO0FBRUYsMERBQTBEO0FBQzFELE1BQU0sYUFBYSxHQUFHLENBQUMsT0FBZSxFQUFrQixFQUFFO0lBQ3hELE1BQU0sU0FBUyxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLE9BQU8sQ0FBQyxDQUFDLFdBQVcsRUFBRSxDQUFDO0lBQzlELElBQUksU0FBUyxLQUFLLE1BQU0sRUFBRSxDQUFDO1FBQ3pCLE9BQU8sS0FBSyxDQUFDO0lBQ2YsQ0FBQztJQUNELElBQUksU0FBUyxLQUFLLE1BQU0sSUFBSSxTQUFTLEtBQUssT0FBTyxFQUFFLENBQUM7UUFDbEQsT0FBTyxNQUFNLENBQUM7SUFDaEIsQ0FBQztJQUNELE1BQU0sSUFBSSxzQkFBc0IsQ0FBQyxrRUFBa0UsQ0FBQyxDQUFDO0FBQ3ZHLENBQUMsQ0FBQztBQUVGOzs7R0FHRztBQUNILE1BQU0sQ0FBQyxNQUFNLHlCQUF5QixHQUFHLENBQUMsR0FBc0MsRUFBUSxFQUFFO0lBQ3hGLEdBQUcsQ0FBQyxHQUFHLENBQUMsT0FBTyxDQUFDO1FBQ2QsSUFBSSxFQUFFLFlBQVk7UUFDbEIsV0FBVyxFQUFFLHNIQUFzSDtRQUNuSSxPQUFPLEVBQUU7WUFDUCxHQUFHLEVBQUUsRUFBRSxJQUFJLEVBQUUsUUFBUSxFQUFFLFFBQVEsRUFBRSxJQUFJLEVBQUUsV0FBVyxFQUFFLDhDQUE4QyxFQUFFO1lBQ3BHLElBQUksRUFBRSxFQUFFLElBQUksRUFBRSxRQUFRLEVBQUUsV0FBVyxFQUFFLG9FQUFvRSxFQUFFO1lBQzNHLFFBQVEsRUFBRSxFQUFFLElBQUksRUFBRSxRQUFRLEVBQUUsV0FBVyxFQUFFLGNBQWMsTUFBTSxDQUFDLE9BQU8sQ0FBQyxxQkFBcUIsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsT0FBTyxFQUFFLFFBQVEsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxHQUFHLE9BQU8sS0FBSyxRQUFRLEdBQUcsQ0FBQyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsOEJBQThCLEVBQUU7WUFDaE0sTUFBTSxFQUFFLEVBQUUsSUFBSSxFQUFFLFFBQVEsRUFBRSxXQUFXLEVBQUUsMERBQTBELEVBQUU7WUFDbkcsS0FBSyxFQUFFLEVBQUUsSUFBSSxFQUFFLFFBQVEsRUFBRSxXQUFXLEVBQUUsK0JBQStCLEVBQUU7WUFDdkUsT0FBTyxFQUFFLEVBQUUsSUFBSSxFQUFFLFFBQVEsRUFBRSxXQUFXLEVBQUUscUVBQXFFLEVBQUU7WUFDL0csS0FBSyxFQUFFLEVBQUUsSUFBSSxFQUFFLFFBQVEsRUFBRSxXQUFXLEVBQUUsd0NBQXdDLEVBQUU7WUFDaEYsT0FBTyxFQUFFLEVBQUUsSUFBSSxFQUFFLFFBQVEsRUFBRSxXQUFXLEVBQUUseUNBQXlDLEVBQUU7U0FDcEY7S0FDRixFQUFFLEtBQUssRUFBRSxFQUFFLElBQUksRUFBRSxPQUFPLEVBQUUsRUFBRSxFQUFFO1FBQzdCLE1BQU0sTUFBTSxHQUFHLGFBQWEsQ0FBQyxPQUFPLENBQUMsR0FBRyxDQUFDLENBQUM7UUFDMUMsTUFBTSxPQUFPLEdBQTZDO1lBQ3hELE9BQU8sRUFBRSxZQUFZLENBQUMsSUFBSSxFQUFFLE9BQU8sQ0FBQyxJQUFJLENBQUM7WUFDekMsUUFBUSxFQUFFLGFBQWEsQ0FBQyxPQUFPLENBQUMsUUFBUSxDQUFDO1lBQ3pDLE1BQU0sRUFBRSxPQUFPLENBQUMsTUFBTTtZQUN0QixLQUFLLEVBQUUsT0FBTyxDQUFDLEtBQWlEO1lBQ2hFLE9BQU8sRUFBRSxPQUFPLENBQUMsT0FBNEQ7WUFDN0UsS0FBSyxFQUFFLE9BQU8sQ0FBQyxLQUEwQjtZQUN6QyxNQUFNO1lBQ04sT0FBTyxFQUFFLE9BQU8sQ0FBQyxPQUFPO1NBQ3pCLENBQUM7UUFDRix5REFBeUQ7UUFDekQsd0JBQXdCLENBQUMsT0FBTyxDQUFDLENBQUM7UUFDbEMsTUFBTSxPQUFPLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsT0FBTyxDQUFDLEdBQUcsQ0FBQyxDQUFDO1FBQ2xELE1BQU0sU0FBUyxHQUFHLElBQUksWUFBWSxDQUFDLEVBQUUsSUFBSSxFQUFFLENBQUMsRUFBRSxHQUFHLEVBQUUsT0FBTyxDQUFDLEdBQUcsRUFBRSxFQUFFLENBQUMsQ0FBQztRQUNwRSx5RkFBeUY7UUFDekYsT0FBTyxDQUFDLFNBQVMsQ0FBQyxnQkFBZ0IsQ0FBQyxPQUFPLENBQUMsRUFBRSxpQkFBaUIsRUFBRSxTQUFTLENBQUMsb0JBQW9CLEVBQUUsRUFBRSxDQUFDLENBQUM7UUFDcEcsSUFBSSxNQUErQyxDQUFDO1FBQ3BELElBQUksQ0FBQztZQUNILE1BQU0sU0FBUyxDQUFDLEtBQUssRUFBRSxDQUFDO1lBQ3hCLE1BQU0sR0FBRyxNQUFNLFNBQVMsQ0FBQyxPQUFPLENBQUMsaUJBQWlCLENBQUMsT0FBTyxDQUFDLENBQUM7UUFDOUQsQ0FBQztnQkFBUyxDQUFDO1lBQ1QsTUFBTSxTQUFTLENBQUMsSUFBSSxFQUFFLENBQUM7UUFDekIsQ0FBQztRQUNELE1BQU0sT0FBTyxDQUFDLEVBQUUsQ0FBQyxTQUFTLENBQUMsT0FBTyxFQUFFLE1BQU0sQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLEtBQUssQ0FBQyxVQUFVLEVBQUUsUUFBUSxDQUFDLENBQUMsQ0FBQztRQUNwRixNQUFNLEVBQUUsU0FBUyxFQUFFLEtBQUssRUFBRSxHQUFHLE1BQU0sQ0FBQztRQUNwQyxNQUFNLEdBQUcsQ0FBQyxHQUFHLENBQ1gsOEJBQThCLE9BQU8sS0FBSyxTQUFTLENBQUMsV0FBVyxJQUFJLFNBQVMsQ0FBQyxRQUFRLFNBQVMsU0FBUyxDQUFDLFNBQVMsS0FBSyxNQUFNLENBQUMsT0FBTyxLQUFLLEtBQUssQ0FBQyxLQUFLLElBQUksS0FBSyxDQUFDLE1BQU0sR0FBRyxNQUFNLENBQUMsU0FBUyxDQUFDLENBQUMsQ0FBQyw2QkFBNkIsQ0FBQyxDQUFDLENBQUMsRUFBRSxHQUFHLENBQ2hPLENBQUM7SUFDSixDQUFDLENBQUMsQ0FBQztBQUNMLENBQUMsQ0FBQyJ9

package/dist_ts/plugins.d.ts

@@ -1,18 +1,22 @@
 import * as childProcess from 'node:child_process';
 import * as fs from 'node:fs/promises';
 import * as fsSync from 'node:fs';
+import * as os from 'node:os';
 import * as path from 'node:path';
 import * as url from 'node:url';
-export { childProcess, fs, fsSync, path, url };
+export { childProcess, fs, fsSync, os, path, url };
 import * as typedrequest from '@api.global/typedrequest';
 import * as typedserver from '@api.global/typedserver';
 export { typedrequest, typedserver };
+import * as deesDomtools from '@design.estate/dees-domtools';
+export { deesDomtools };
 import * as tswatch from '@git.zone/tswatch';
 export { tswatch };
+import * as smartbrowser from '@push.rocks/smartbrowser/automation';
 import * as smartconfig from '@push.rocks/smartconfig';
 import * as smartconsole from '@push.rocks/smartconsole';
 import * as smartexit from '@push.rocks/smartexit';
-export { smartconfig, smartconsole, smartexit };
+export { smartbrowser, smartconfig, smartconsole, smartexit };
 import typescript from 'typescript';
 export { typescript };
 import * as interfaces from '../dist_ts_interfaces/index.js';