@antelopejs/dms-frontend 0.3.8 → 0.3.9

package/README.md

@@ -71,6 +71,8 @@ pnpm add @antelopejs/core @antelopejs/dms-frontend
 pnpm add -g @antelopejs/core @antelopejs/dms-frontend
 ```
 
+The plugin prints through the output module of `@antelopejs/core`
+(`@antelopejs/core/cli`), so it needs `@antelopejs/core` 1.13.0 or later.
 `npm install -g` works too; this repository and every generated workspace use
 pnpm. Inside a package script, `ajs` resolves from `node_modules/.bin`, and the
 `dms` command it delegates to resolves the project-local plugin, so a script
@@ -83,25 +85,68 @@ ajs dms prepare -b http://localhost:5010
 ajs dms dev -b http://localhost:5010 -p 3001
 ajs dms build -b https://dms.example.com
 ajs dms start -b https://dms.example.com -p 3001
+ajs dms workspaces
+ajs dms workspaces --json
 ajs dms clean -b https://dms.example.com
 ajs dms clean --all
+ajs dms help environment
 ```
 
-`--help`, `--version` and `clean` run from any directory. `prepare` also runs
-anywhere: with no backend in reach it warns and exits 0, so a frontend module's
-`postinstall` hook never fails an install, and the generated types are refreshed
-later from a development environment. `dev`, `build` and `start` need a backend
-URL, either through `-b` or through the enclosing antelope project's
-`.antelope/dev.json`, and say so on exit 1 when they have neither;
+`ajs dms <command> --help` shows what a command does, its options and a few
+examples. `ajs dms help environment` lists every variable the CLI and the
+generated server read, from the environment or the project's `.env`.
+
+`--help`, `--version`, `workspaces` and `clean` run from any directory. `build` and `start`
+need a backend URL through `-b` or `DMS_API_BASE_URL`, and exit 2 without one.
+`dev` also discovers it from the enclosing antelope project's
+`.antelope/dev.json`, and exits 1 when there is none to discover.
 `verify-source` needs `--layer` instead.
 
+`prepare` runs anywhere: when it cannot prepare the workspace it warns on
+stderr and exits 0, so a frontend module's `postinstall` hook never fails an
+install. The warning says whether prepare was skipped or failed. Skipped means
+no backend is in reach (no URL, an unreachable backend, `--offline` without a
+cached manifest), as in CI: the generated types are refreshed later from a
+development environment. Failed means something a later run will not fix: a
+refused credential, an incompatible manifest or renderer range, an invalid URL.
+A step that needs the types, such as a CI type-check, passes `--strict` (or
+sets `DMS_PREPARE_STRICT=1`): prepare then exits 1 in every one of these cases,
+and 2 when the backend URL is missing or invalid. On success, it says how many
+modules it found and how long it took.
+
+`build` ends with where it wrote the production frontend (the `dist`
+directory of the workspace), how long it took, and the `ajs dms start` command
+to run next, with the same backend URL and `DMS_SESSION_SECRET`. Its output is
+deployed, so it never builds silently from the cache: when the backend cannot
+be reached or fails, `build` exits 1, says whether a cached manifest exists and
+how old it is, and builds from it only when asked with `--offline`. `dev` and
+`prepare` still fall back to the cache, with a warning.
+
+The commands follow the output contract of `ajs`: what the CLI itself prints
+on stdout is only the help and the version, and everything else (progress,
+warnings, errors) goes to stderr. The dependency install and each step of the
+production build run as one progress line each: their output is kept and its
+last lines are shown when they fail, with paths into the generated workspace
+pointing at the frontend-module sources instead. The server `dev` and `start`
+run keeps its own output. A command exits 0 on success, 1 on a failure, 2 on a
+usage error (an unknown command or option, a missing or invalid argument, a
+missing configuration value) and 130 when stopped with Ctrl+C. `--no-color` or
+`NO_COLOR=1` turns colors off, and terminals that cannot draw Unicode, such as
+`TERM=dumb`, get ASCII symbols. `--verbose` or `ANTELOPEJS_VERBOSE` streams
+the full `pnpm` and Vite output, each line behind the name of the step, and adds
+the stack trace of the underlying error to a failure. `ajs --no-color dms …`,
+`ajs --verbose dms …` and `ajs --verbose=<channels> dms …` set those variables
+for the plugin.
+
 The CLI checks npm for a newer release at most once a day and prints a one-line
-notice on stderr. A lookup that comes back empty — offline, throttled, or simply
-raced by a command that blocked the event loop past the deadline — is retried
-after an hour instead of counting as the day's attempt. The throttle stamp lives
-at `~/.antelopejs/dms-frontend/update-check.json`. Set
-`NO_UPDATE_NOTIFIER=1`, pass `--no-update-check`, or run under `CI` to turn the
-check off.
+notice on stderr, only to a terminal: as the last line of a command that
+succeeded, or under the ready block of `dev` and `start`. Help, `--version`,
+`--json`, failed commands, pipes and `TERM=dumb` never show it. The lookup starts
+with the command and never delays its exit; a lookup that comes back empty —
+offline or throttled — is retried after an hour instead of counting as the day's
+attempt. The throttle stamp lives at
+`~/.antelopejs/dms-frontend/update-check.json`. Set `NO_UPDATE_NOTIFIER=1`, pass
+`--no-update-check`, or run under `CI` to turn the check off.
 
 Manifest negotiation and module materialization are the renderer contract described in [Renderers](#renderers).
 
@@ -151,7 +196,7 @@ A frontend module names the `@antelopejs/dms-frontend` releases it runs on in it
 }
 ```
 
-`prepare`, `dev`, `build` and `verify-source` read it before they generate anything, whether the manifest was just fetched or replayed from the cache, and stop when this release falls outside a module's range: `dev`, `build` and `verify-source` exit 1, and `prepare` warns and exits 0, as it does for any setup it cannot complete. The message names each such module, its range and this release, rather than letting the build, the type-check or a render fail later on an API the release no longer has, or does not have yet. A prerelease is checked as the release it leads to: `0.4.0-next.1` is outside `<0.4.0`. A module that declares no range still loads, and a warning names it once. `start` checks nothing: it runs what `build` produced.
+`prepare`, `dev`, `build` and `verify-source` read it before they generate anything, whether the manifest was just fetched or replayed from the cache, and stop when this release falls outside a module's range: `dev`, `build` and `verify-source` exit 1, and `prepare` warns and exits 0, as it does for any setup it cannot complete, unless `--strict` is given. The message names each such module, its range and this release, rather than letting the build, the type-check or a render fail later on an API the release no longer has, or does not have yet. A prerelease is checked as the release it leads to: `0.4.0-next.1` is outside `<0.4.0`. A module that declares no range still loads, and a warning names it once. `start` checks nothing: it runs what `build` produced.
 
 Cap the range below the next breaking release, which is the next minor release while this package is 0.x, and widen it once the module has been checked against that release. A range left open to `<1.0.0` admits the very release that removes something the module calls.
 
@@ -213,7 +258,7 @@ which is the order the loader itself materializes them in.
 
 In development, `ajs dms` discovers the backend from the nearest live `.antelope/dev.json`. It reads the local bootstrap credential from `.antelope/dms-dev.json` only when that discovered backend matches the destination URL. For production and CI, set `DMS_API_BASE_URL` and `DMS_BOOTSTRAP_SECRET` in the environment, or in the project's `.env`, rather than passing credentials on the command line.
 
-Each canonical backend URL gets an owner-only workspace under `~/.antelopejs/dms-frontend` (see [Workspaces](#workspaces) for how the key is derived). Manifest caches, private module configuration, and extracted archives retain restrictive permissions. `--offline` reuses the last successful manifest and archive; an authorization failure never falls back to privileged cached data.
+Each canonical backend URL gets an owner-only workspace under `~/.antelopejs/dms-frontend` (see [Workspaces](#workspaces) for how the key is derived). Manifest caches, private module configuration, and extracted archives retain restrictive permissions. `--offline` reuses the last successful manifest and archive; `dev` and `prepare` also fall back to them when the backend cannot be reached or fails, and `build` only with `--offline`. An authorization failure never falls back to privileged cached data.
 
 ## Configuration
 
@@ -324,9 +369,21 @@ different port between runs and re-keying on the URL would discard
 `node_modules`, the manifest cache and the client-side appId scope every time it
 does. The consequence is that `ajs dms dev` followed by `ajs dms build -b <url>`
 against the same backend creates two workspaces of their own — several hundred
-megabytes each. Pass `-b` to `dev` to share a single one. `clean --all` lists
-both and names the project a workspace is keyed on; `clean -b <url>` only
-reaches the URL-keyed one.
+megabytes each. Pass `-b` to `dev` to share a single one. `workspaces` lists
+both, with the project a workspace is keyed on, its size and its last use;
+`clean -b <url>` only reaches the URL-keyed one. `clean` takes its target from
+`-b` or `--all` only: it never reads `DMS_API_BASE_URL` from the environment or
+`.env`, so running it without either is an error rather than a deletion.
+
+`workspaces` prints an aligned table on a terminal. Piped, it prints one
+tab-separated line per workspace, without a header: id, backend URL, key type
+(`url` or `project`), project directory, size in bytes, last use (ISO 8601) and
+workspace directory. `--json` prints one JSON document with the same fields;
+everything else the command says goes to stderr.
+
+`clean --all` lists what it removes and asks before removing it. Without a
+terminal to ask on (a pipe, CI), it exits 2 unless `--yes` is given. Both forms
+of `clean` say how much space they freed.
 
 A `DMS_API_BASE_URL` line in `.env` counts as an explicit backend, so a project
 that configures one gets the single shared workspace and gives up autodiscovery
@@ -378,11 +435,13 @@ needs no exception for the Iconify API. Icons reach the page two ways:
 
 | Option | Environment | Purpose |
 | --- | --- | --- |
-| `-b, --backend-url` | `DMS_API_BASE_URL` | DMS backend URL |
-| `-p, --port` | `PORT` | Frontend port, default `3001` |
-| `-f, --force` | | Reinstall workspace dependencies |
-| `--offline` | `DMS_OFFLINE` | Reuse cached manifest and archives |
+| `-b, --backend-url` | `DMS_API_BASE_URL` (except `clean`) | DMS backend URL, `http://` or `https://` |
+| `-p, --port` | `PORT` | Frontend port from 1 to 65535, default `3001`; `dev` moves to the next free port, `start` stops when it is in use |
+| `-f, --force` | | Reinstall workspace dependencies; `build` also extracts the layers archive from scratch |
+| `--offline` | `DMS_OFFLINE` | Reuse cached manifest and archives; the only way `build` uses them |
+| `--strict` | `DMS_PREPARE_STRICT` | Make `prepare` fail instead of warning; see [Commands](#commands) |
 | `--bootstrap-secret` | `DMS_BOOTSTRAP_SECRET` | Backend bootstrap credential |
+| | `HOST` | Address the frontend server binds to (default `0.0.0.0`) |
 | | `DMS_COOKIE_SECURE` | Secure cookies (`true` by default; `ajs dms dev` defaults to `false`) |
 | | `DMS_TRUSTED_PROXY_HOPS` | Number of trusted, rightmost reverse-proxy hops (default `0`) |
 | | `DMS_SESSION_SECRET` | Session cookie encryption key, 32 characters or more (required for login) |
@@ -393,7 +452,7 @@ needs no exception for the Iconify API. Icons reach the page two ways:
 
 All of these can be set in the project's `.env` instead of the environment; see [Configuration](#configuration).
 
-`ajs dms dev` takes the two manifest secrets from the manifest it fetches, and `ajs dms start` from the manifest cached by `ajs dms build`. An explicitly set variable always wins over the manifest value. Before the server starts, both commands log where each secret comes from (`env`, `manifest`, `build-time manifest` or `not set`), never its value. When several modules publish the same secret, the first one in manifest-priority order wins, and a module publishing a different value is named in a warning.
+`ajs dms dev` takes the two manifest secrets from the manifest it fetches, and `ajs dms start` from the manifest cached by `ajs dms build`. An explicitly set variable always wins over the manifest value. Before the server starts, both commands warn about each secret that is not set and what stops working without it; once the server is ready, they list where the others come from (the environment, the manifest or the build-time manifest), never their values. When several modules publish the same secret, the first one in manifest-priority order wins, and a module publishing a different value is named in a warning.
 
 Use pnpm for all repository and workspace operations.
 
@@ -408,6 +467,6 @@ ajs dms verify-source \
   --local-package @antelopejs/dms=/path/to/dms
 ```
 
-A supplied package whose declared range excludes this adapter version is refused before anything is installed (see [Declaring the loader releases a module supports](#declaring-the-loader-releases-a-module-supports)). The verifier prints its generated workspace path, builds client, SSR, and email bundles, runs `vue-tsc`, renders eight DMS email templates, and checks that the email bundle excludes browser-only modules. It leaves the generated workspace in the temporary directory for inspection. It does not start a backend or publish packages. Repository development can invoke the same runner with `DMS_LAYER_SOURCE` through `pnpm test:real-source`.
+A supplied package whose declared range excludes this adapter version is refused before anything is installed (see [Declaring the loader releases a module supports](#declaring-the-loader-releases-a-module-supports)). The verifier generates a temporary workspace, installs it, builds client, SSR, and email bundles, checks what the client bundle loads, runs `vue-tsc`, renders eight DMS email templates, and checks that the email bundle excludes browser-only modules. Each check is one line that ends in ✔ or ✖, and the run ends with `Verified <n> modules` and its duration, or with the first failure: a type or Vite error points at the file in the package you passed (`./frontend-vue/app/components/Callout.vue:17:7`), not at its copy in the workspace, and the command exits 1. `--verbose` streams the pnpm, Vite and `vue-tsc` output. The workspace is removed when the run ends. It does not start a backend or publish packages. Repository development can invoke the same runner with `DMS_LAYER_SOURCE` through `pnpm test:real-source`.
 
 Refresh rotation is single-flight within one frontend process. Horizontally scaled deployments must use sticky routing so a browser reaches the same process, or replace this process-local behavior with an external session adapter. It does not provide a distributed rotation guarantee.

package/dist/cancellation.d.ts

@@ -0,0 +1,8 @@
+export declare function exitCodeForSignal(signal: NodeJS.Signals): number;
+export declare class CancelledError extends Error {
+    readonly signal: NodeJS.Signals;
+    readonly exitCode: number;
+    readonly stopped: string;
+    readonly context: string[];
+    constructor(signal: NodeJS.Signals, stopped?: string, context?: string);
+}

package/dist/cancellation.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CancelledError = void 0;
+exports.exitCodeForSignal = exitCodeForSignal;
+const node_os_1 = require("node:os");
+const cli_1 = require("@antelopejs/core/cli");
+function exitCodeForSignal(signal) {
+    const number = node_os_1.constants.signals[signal];
+    return 128 + (typeof number === "number" ? number : 15);
+}
+class CancelledError extends Error {
+    constructor(signal, stopped = "Stopped", context) {
+        const cause = signal === "SIGINT" ? "" : ` (${signal})`;
+        const parts = [`${stopped}${cause}`, ...(context ? [context] : [])];
+        super(parts.join((0, cli_1.getProcessUi)().symbols.separator));
+        this.signal = signal;
+        this.name = "CancelledError";
+        this.exitCode = exitCodeForSignal(signal);
+        this.stopped = parts[0];
+        this.context = parts.slice(1);
+    }
+}
+exports.CancelledError = CancelledError;

package/dist/child-output.d.ts

@@ -0,0 +1,45 @@
+import { type CliProblem, type Ui } from "@antelopejs/core/cli";
+import type { ResolvedLayer } from "./workspace";
+export declare const VERBOSE_OUTPUT_HINT = "Run with --verbose for the full output.";
+export declare function stripAnsi(text: string): string;
+export declare class LineSplitter {
+    private readonly onLine;
+    private pending;
+    constructor(onLine: (line: string) => void);
+    push(chunk: string): void;
+    flush(): void;
+}
+export declare class OutputTail {
+    private readonly capacity;
+    private readonly kept;
+    constructor(capacity?: number);
+    push(line: string): void;
+    lines(): string[];
+}
+export declare function failureTail(lines: string[], count?: number, keepStack?: boolean): string[];
+export interface ChildFailure {
+    title: string;
+    command: string;
+    code: number;
+    lines: string[];
+    isVerbose: boolean;
+}
+export declare function describeChildFailure(failure: ChildFailure): CliProblem;
+export type PathMapper = (line: string) => string;
+export interface PathMapperOptions {
+    showSource?: (path: string) => string;
+    shownWorkspace?: string;
+    platform?: NodeJS.Platform;
+}
+export declare function createFileNamer(layers: ResolvedLayer[]): (file: string) => string;
+export declare function createPathMapper(workspaceDir: string, layers: ResolvedLayer[], options?: PathMapperOptions): PathMapper;
+export declare function writeChildLine(name: string, line: string, ui?: Ui): void;
+export declare class InstallProgress {
+    private resolved?;
+    private added?;
+    private installed?;
+    private isUpToDate;
+    read(line: string): boolean;
+    get label(): string;
+    get doneLabel(): string;
+}

package/dist/child-output.js

@@ -0,0 +1,183 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InstallProgress = exports.OutputTail = exports.LineSplitter = exports.VERBOSE_OUTPUT_HINT = void 0;
+exports.stripAnsi = stripAnsi;
+exports.failureTail = failureTail;
+exports.describeChildFailure = describeChildFailure;
+exports.createFileNamer = createFileNamer;
+exports.createPathMapper = createPathMapper;
+exports.writeChildLine = writeChildLine;
+const node_fs_1 = require("node:fs");
+const cli_1 = require("@antelopejs/core/cli");
+const layers_1 = require("./layers");
+const output_1 = require("./output");
+const ESC = "\u001b";
+const ANSI_SEQUENCE = new RegExp(`${ESC}\\[[0-9;?]*[ -/]*[@-~]`, "g");
+const LINE_BREAK = /\r?\n/;
+const STACK_FRAME = /^\s+at\s/;
+const NODE_DEPRECATION_LINES = [
+    /^\(node:\d+\) \[DEP\d+\]/,
+    /^\(Use `node --trace-/,
+];
+const GUTTER_BARS = { unicode: "│", ascii: "|" };
+const KEPT_OUTPUT_LINES = 200;
+const FAILURE_TAIL_LINES = 15;
+exports.VERBOSE_OUTPUT_HINT = "Run with --verbose for the full output.";
+function stripAnsi(text) {
+    return text.replace(ANSI_SEQUENCE, "");
+}
+class LineSplitter {
+    constructor(onLine) {
+        this.onLine = onLine;
+        this.pending = "";
+    }
+    push(chunk) {
+        const lines = `${this.pending}${chunk}`.split(LINE_BREAK);
+        this.pending = lines.pop() ?? "";
+        lines.forEach((line) => this.onLine(line));
+    }
+    flush() {
+        if (this.pending !== "")
+            this.onLine(this.pending);
+        this.pending = "";
+    }
+}
+exports.LineSplitter = LineSplitter;
+class OutputTail {
+    constructor(capacity = KEPT_OUTPUT_LINES) {
+        this.capacity = capacity;
+        this.kept = [];
+    }
+    push(line) {
+        this.kept.push(line);
+        if (this.kept.length > this.capacity)
+            this.kept.shift();
+    }
+    lines() {
+        return [...this.kept];
+    }
+}
+exports.OutputTail = OutputTail;
+function failureTail(lines, count = FAILURE_TAIL_LINES, keepStack = false) {
+    const shown = lines
+        .map((line) => stripAnsi(line).trimEnd())
+        .filter((line) => line.trim() !== "")
+        .filter((line) => !NODE_DEPRECATION_LINES.some((notice) => notice.test(line)))
+        .filter((line) => keepStack || !STACK_FRAME.test(line));
+    return shown.slice(Math.max(0, shown.length - count));
+}
+function describeChildFailure(failure) {
+    const { title, command, code, lines, isVerbose } = failure;
+    if (isVerbose) {
+        return {
+            title,
+            reason: `${command} exited with code ${code}; its output is above.`,
+        };
+    }
+    return {
+        title,
+        reason: `${command} exited with code ${code}.`,
+        details: [...failureTail(lines), exports.VERBOSE_OUTPUT_HINT],
+    };
+}
+const PATH_END = "(?![\\w.@-])";
+const RELATIVE_START = `(?:(?<=${ESC}\\[[0-9;]*m)|(?<![\\w.@/\\\\-]))`;
+const LAYERS_SUBDIR = "frontend-modules";
+function escapeRegExp(text) {
+    return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function pathPattern(path) {
+    return path
+        .split(/[\\/]/)
+        .map((segment) => escapeRegExp(segment))
+        .join("[\\\\/]");
+}
+function hasLocalSource(layer) {
+    return !!layer.sourcePath && (0, node_fs_1.existsSync)(layer.sourcePath);
+}
+function shownSource(layer, showSource) {
+    if (hasLocalSource(layer))
+        return showSource(layer.sourcePath ?? "");
+    return layer.packageName ?? (0, layers_1.getLayerSafeName)(layer);
+}
+function createFileNamer(layers) {
+    const packages = layers
+        .filter((layer) => layer.packageName && !hasLocalSource(layer))
+        .map((layer) => shownSource(layer, output_1.showPath));
+    return (file) => {
+        const owner = packages.find((name) => ["/", "\\"].some((separator) => file.startsWith(`${name}${separator}`)));
+        if (!owner)
+            return file;
+        return `${file.slice(owner.length + 1)} in ${owner}`;
+    };
+}
+function createPathMapper(workspaceDir, layers, options = {}) {
+    const { showSource = output_1.showPath, shownWorkspace = (0, output_1.showWorkspace)(workspaceDir), platform = process.platform, } = options;
+    const flags = platform === "win32" ? "gi" : "g";
+    const layerRules = layers
+        .filter((layer) => layer.packageName)
+        .flatMap((layer) => {
+        const shown = shownSource(layer, showSource);
+        const copy = pathPattern((0, layers_1.getLayerWorkspacePath)(workspaceDir, layer));
+        const relative = `${RELATIVE_START}${pathPattern(`${LAYERS_SUBDIR}/${(0, layers_1.getLayerSafeName)(layer)}`)}`;
+        return [copy, relative].map((pattern) => ({
+            pattern: new RegExp(`${pattern}${PATH_END}`, flags),
+            shown,
+        }));
+    });
+    const rules = [
+        ...layerRules,
+        {
+            pattern: new RegExp(`${pathPattern(workspaceDir)}${PATH_END}`, flags),
+            shown: shownWorkspace,
+        },
+    ];
+    return (line) => rules.reduce((mapped, { pattern, shown }) => mapped.replace(pattern, () => shown), line);
+}
+function hasFeedbackColor() {
+    return (0, cli_1.detectCapabilities)((0, cli_1.processCapabilityContext)()).colors.feedback;
+}
+function writeChildLine(name, line, ui = (0, cli_1.getProcessUi)()) {
+    const isUnicode = ui.symbols === cli_1.SYMBOL_SETS.unicode;
+    const bar = isUnicode ? GUTTER_BARS.unicode : GUTTER_BARS.ascii;
+    const text = hasFeedbackColor() ? line : stripAnsi(line);
+    (0, cli_1.getProcessTasks)().write(process.stderr, `${ui.palette().dim(`${name} ${bar}`)} ${text}\n`);
+}
+const PROGRESS_LINE = /^Progress: resolved (\d+), reused \d+, downloaded \d+, added (\d+)/;
+const PACKAGES_LINE = /^Packages: \+(\d+)/;
+const UP_TO_DATE_LINE = /^Already up to date/;
+class InstallProgress {
+    constructor() {
+        this.isUpToDate = false;
+    }
+    read(line) {
+        const progress = PROGRESS_LINE.exec(line);
+        if (progress) {
+            this.resolved = Number(progress[1]);
+            this.added = Number(progress[2]);
+            return true;
+        }
+        const packages = PACKAGES_LINE.exec(line);
+        if (packages)
+            this.installed = Number(packages[1]);
+        if (UP_TO_DATE_LINE.test(line))
+            this.isUpToDate = true;
+        return false;
+    }
+    get label() {
+        if (this.resolved === undefined)
+            return "Installing dependencies";
+        return [
+            "Installing dependencies",
+            `${this.resolved} resolved, ${this.added ?? 0} added`,
+        ].join((0, cli_1.getProcessUi)().symbols.separator);
+    }
+    get doneLabel() {
+        if (this.installed !== undefined)
+            return `Installed ${(0, cli_1.pluralize)(this.installed, "package")}`;
+        if (this.isUpToDate)
+            return "Dependencies up to date";
+        return "Installed the dependencies";
+    }
+}
+exports.InstallProgress = InstallProgress;

package/dist/commands/build-action.d.ts

@@ -0,0 +1,21 @@
+import { CliError } from "@antelopejs/core/cli";
+import { type FramedCommandResult } from "../common";
+export interface BuildOptions {
+    backendUrl?: string;
+    force?: boolean;
+    offline?: boolean;
+    bootstrapSecret?: string;
+}
+interface BuildStep {
+    script: string;
+    name: string;
+    subject: string;
+    running: string;
+    done: string;
+    failed: string;
+    stopped: string;
+}
+export declare const BUILD_STEPS: BuildStep[];
+export declare function buildStepFailure(step: BuildStep, result: FramedCommandResult, isVerbose: boolean, rerun?: string, nameFile?: (file: string) => string): CliError;
+export declare function runBuild(options: BuildOptions): Promise<void>;
+export {};

package/dist/commands/build-action.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BUILD_STEPS = void 0;
+exports.buildStepFailure = buildStepFailure;
+exports.runBuild = runBuild;
+const node_path_1 = require("node:path");
+const cli_1 = require("@antelopejs/core/cli");
+const child_output_1 = require("../child-output");
+const common_1 = require("../common");
+const output_1 = require("../output");
+const vite_output_1 = require("../vite-output");
+const workspace_task_1 = require("./workspace-task");
+exports.BUILD_STEPS = [
+    {
+        script: "build:client",
+        name: "client",
+        subject: "client bundle",
+        running: "Building the client bundle",
+        done: "Built the client bundle",
+        failed: "Client bundle failed",
+        stopped: "Client bundle stopped",
+    },
+    {
+        script: "build:compress",
+        name: "compress",
+        subject: "compressed assets",
+        running: "Compressing the client assets",
+        done: "Compressed the client assets",
+        failed: "Asset compression failed",
+        stopped: "Asset compression stopped",
+    },
+    {
+        script: "build:ssr",
+        name: "ssr",
+        subject: "SSR bundle",
+        running: "Building the SSR bundle",
+        done: "Built the SSR bundle",
+        failed: "SSR bundle failed",
+        stopped: "SSR bundle stopped",
+    },
+    {
+        script: "build:email",
+        name: "email",
+        subject: "e-mail bundle",
+        running: "Building the e-mail bundle",
+        done: "Built the e-mail bundle",
+        failed: "E-mail bundle failed",
+        stopped: "E-mail bundle stopped",
+    },
+];
+function buildStepFailure(step, result, isVerbose, rerun, nameFile) {
+    const problem = (0, vite_output_1.describeViteFailure)(result.lines, step.subject, isVerbose, rerun, nameFile) ??
+        (0, child_output_1.describeChildFailure)({
+            title: "The production build failed",
+            command: `pnpm run ${step.script}`,
+            code: result.code,
+            lines: result.lines,
+            isVerbose,
+        });
+    return new cli_1.CliError(problem);
+}
+async function runBuildStep(step, context) {
+    const task = (0, cli_1.getProcessTasks)().start(step.running);
+    let result;
+    try {
+        result = await (0, common_1.runFramedCommand)("pnpm", ["--silent", "run", step.script], {
+            name: step.name,
+            cwd: context.workspaceDir,
+            env: context.env,
+            mapLine: context.mapLine,
+            onLine: (line) => context.warnings.read(line),
+        });
+    }
+    catch (error) {
+        (0, output_1.endInterruptedTask)(task, error, step.stopped);
+        throw error;
+    }
+    if (result.code !== 0) {
+        task.fail(step.failed);
+        throw buildStepFailure(step, result, context.isVerbose, undefined, context.nameFile);
+    }
+    task.succeed(step.done);
+}
+async function runBuild(options) {
+    const startedAt = Date.now();
+    try {
+        await buildProduction(options, startedAt);
+    }
+    catch (error) {
+        if (!(error instanceof common_1.CancelledError))
+            throw error;
+        throw new common_1.CancelledError(error.signal, "Stopped the production build", `ran ${(0, cli_1.formatDuration)(Date.now() - startedAt)}`);
+    }
+}
+async function buildProduction(options, startedAt) {
+    const backendUrl = (0, common_1.requireBackendUrl)(options.backendUrl);
+    const sessionSecret = (0, common_1.resolveSessionSecret)("build");
+    const bootstrapSecret = (0, common_1.normalizeBootstrapSecret)(options.bootstrapSecret);
+    const ui = (0, cli_1.getProcessUi)();
+    (0, output_1.writeHeader)("build", [backendUrl, "production"]);
+    const { workspaceDir, layers, manifestFromCache, manifestFetchedAt } = await (0, workspace_task_1.setUpWorkspace)({
+        backendUrl,
+        force: !!options.force,
+        mode: "build",
+        offline: (0, common_1.flagOrEnv)(options.offline, "DMS_OFFLINE"),
+        bootstrapSecret,
+    });
+    if (manifestFromCache) {
+        ui.message("warn", `Building from the manifest and layers archive${(0, output_1.cachedAge)(manifestFetchedAt)}`, { detail: "The output may not match the current backend." });
+    }
+    ui.message("info", "Building for production", {
+        detail: `Workspace  ${(0, output_1.showWorkspace)(workspaceDir)}`,
+    });
+    const isVerbose = (0, cli_1.isVerboseRun)();
+    const context = {
+        workspaceDir,
+        isVerbose,
+        warnings: new vite_output_1.ViteWarnings(),
+        mapLine: (0, child_output_1.createPathMapper)(workspaceDir, layers),
+        nameFile: (0, child_output_1.createFileNamer)(layers),
+        env: {
+            ...process.env,
+            DMS_SESSION_SECRET: sessionSecret,
+            NODE_OPTIONS: "--max-old-space-size=4096",
+            NODE_PATH: (0, node_path_1.join)(workspaceDir, "node_modules"),
+            [vite_output_1.VITE_LOG_LEVEL_VARIABLE]: (0, vite_output_1.viteLogLevel)(isVerbose),
+        },
+    };
+    for (const step of exports.BUILD_STEPS)
+        await runBuildStep(step, context);
+    (0, vite_output_1.reportViteWarnings)(context.warnings, isVerbose, ui);
+    (0, output_1.writeBlankLine)();
+    ui.summary({
+        headline: "Built the production frontend",
+        artifact: `${(0, output_1.showWorkspace)(workspaceDir)}${node_path_1.sep}dist`,
+        durationMs: Date.now() - startedAt,
+        nextSteps: [
+            {
+                command: `ajs dms start -b ${backendUrl}`,
+                description: "with the DMS_SESSION_SECRET this build used",
+            },
+        ],
+    });
+}