@antelopejs/dms-frontend 0.0.1

package/dist/layers.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertLayerPathsServed = assertLayerPathsServed;
+exports.assertCachedArchivesExist = assertCachedArchivesExist;
+exports.buildLayersFromPaths = buildLayersFromPaths;
+exports.downloadAndExtractLayers = downloadAndExtractLayers;
+exports.buildLayersFromCache = buildLayersFromCache;
+exports.getLayerSafeName = getLayerSafeName;
+exports.getLayerWorkspacePath = getLayerWorkspacePath;
+const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const node_stream_1 = require("node:stream");
+const consumers_1 = require("node:stream/consumers");
+const unzipper_1 = require("unzipper");
+const manifest_1 = require("./manifest");
+const workspace_1 = require("./workspace");
+const fs_sync_1 = require("./fs-sync");
+const config_1 = require("./config");
+function assertLayerPathsServed(modules) {
+    const pathless = modules.filter((mod) => !mod.path);
+    if (pathless.length === 0)
+        return;
+    throw new Error("The backend served a manifest without layer source paths:\n" +
+        pathless.map((mod) => `  - ${mod.name}`).join("\n") +
+        "\n`ajs-dms dev` needs a development backend running on this machine (started with " +
+        "`ajs project dev`); use `ajs-dms build` against a remote or production one.\n" +
+        "If the backend is local and in development mode, it did not recognize the bootstrap " +
+        "credential — see DMS_BOOTSTRAP_SECRET.");
+}
+function assertCachedArchivesExist(modules, cacheDir, fetchedAt) {
+    const present = new Set((0, node_fs_1.readdirSync)(cacheDir));
+    const missing = modules.filter((mod) => !present.has(mod.archiveName));
+    if (missing.length === 0)
+        return;
+    throw new Error(`Cached layers archive is missing entries listed in the manifest${fetchedAt ? ` (fetched ${fetchedAt})` : ""}:\n` +
+        missing.map((mod) => `  - ${mod.name}: ${mod.archiveName}`).join("\n") +
+        "\nRun once with the backend reachable to re-download the layers.");
+}
+function sortModulesByPriority(modules) {
+    return [...modules].sort((a, b) => b.priority - a.priority);
+}
+function readLayerPackageName(layerPath) {
+    const pkgPath = (0, node_path_1.join)(layerPath, "package.json");
+    if (!(0, node_fs_1.existsSync)(pkgPath))
+        return undefined;
+    try {
+        const pkg = JSON.parse((0, node_fs_1.readFileSync)(pkgPath, "utf-8"));
+        return typeof pkg.name === "string" ? pkg.name : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function resolveLayer(layerPath, mod) {
+    return {
+        path: layerPath,
+        packageName: readLayerPackageName(layerPath),
+        priority: mod.priority,
+        configKey: mod.configKey,
+        options: mod.options,
+    };
+}
+function buildLayersFromPaths(modules) {
+    assertLayerPathsServed(modules);
+    return sortModulesByPriority(modules).map((mod) => resolveLayer(mod.path, mod));
+}
+async function downloadAndExtractLayers(backendUrl, packUrl, cacheDir, force, bootstrapSecret) {
+    const url = `${backendUrl}${packUrl}`;
+    const response = await fetch(url, {
+        headers: (0, workspace_1.bootstrapHeaders)(bootstrapSecret),
+    });
+    if ((0, workspace_1.isUnauthorized)(response.status)) {
+        throw new manifest_1.ManifestUnauthorizedError(url, response.status);
+    }
+    if (!response.ok || !response.body) {
+        throw new Error("Failed to download layers archive");
+    }
+    const modulesBlob = await (0, consumers_1.buffer)(node_stream_1.Readable.fromWeb(response.body));
+    const cacheExists = (0, node_fs_1.existsSync)(cacheDir);
+    if (force || !cacheExists) {
+        if (cacheExists) {
+            (0, node_fs_1.rmSync)(cacheDir, { recursive: true, force: true });
+        }
+        await (await unzipper_1.Open.buffer(modulesBlob)).extract({ path: cacheDir });
+        return;
+    }
+    const tempDir = `${cacheDir}_temp`;
+    if ((0, node_fs_1.existsSync)(tempDir)) {
+        (0, node_fs_1.rmSync)(tempDir, { recursive: true, force: true });
+    }
+    await (await unzipper_1.Open.buffer(modulesBlob)).extract({ path: tempDir });
+    const tempEntries = (0, node_fs_1.readdirSync)(tempDir);
+    for (const entry of tempEntries) {
+        (0, fs_sync_1.syncDirectories)((0, node_path_1.join)(tempDir, entry), (0, node_path_1.join)(cacheDir, entry));
+    }
+    (0, node_fs_1.rmSync)(tempDir, { recursive: true, force: true });
+}
+async function buildLayersFromCache(modules, cacheDir) {
+    if (!(0, node_fs_1.existsSync)(cacheDir))
+        return [];
+    const layerFiles = await (0, promises_1.readdir)(cacheDir);
+    const layers = [];
+    for (const mod of sortModulesByPriority(modules)) {
+        if (!layerFiles.includes(mod.archiveName))
+            continue;
+        const layerPath = (0, node_path_1.join)(cacheDir, mod.archiveName);
+        layers.push(resolveLayer(layerPath, mod));
+    }
+    return layers;
+}
+function getLayerSafeName(layer) {
+    if (layer.packageName) {
+        return layer.packageName.replace(/^@/, "").replace(/\//g, "__");
+    }
+    return (0, node_path_1.basename)(layer.path);
+}
+function getLayerWorkspacePath(workspaceDir, layer) {
+    return (0, node_path_1.join)(workspaceDir, config_1.LAYERS_SUBDIR, getLayerSafeName(layer));
+}

package/dist/manifest.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ManifestUnauthorizedError = void 0;
+exports.fetchManifest = fetchManifest;
+exports.readCachedManifest = readCachedManifest;
+exports.resolveManifest = resolveManifest;
+exports.assertCachedLayerPathsExist = assertCachedLayerPathsExist;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const config_1 = require("./config");
+const workspace_1 = require("./workspace");
+class ManifestUnauthorizedError extends Error {
+    constructor(url, status) {
+        super(`Backend refused the layers request (${status}) at ${url}.\n` +
+            "  This DMS backend requires a bootstrap credential for its layer endpoints.\n" +
+            "  • Production/CI: set DMS_BOOTSTRAP_SECRET to the backend's frontend.bootstrapSecret.\n" +
+            "  • Local dev: run inside the antelope project started with `ajs project dev` —\n" +
+            "    the credential is read from .antelope/dms-dev.json automatically.");
+        this.url = url;
+        this.status = status;
+        this.name = "ManifestUnauthorizedError";
+    }
+}
+exports.ManifestUnauthorizedError = ManifestUnauthorizedError;
+async function fetchManifest(backendUrl, clientUrl, bootstrapSecret) {
+    const frontendUrl = new URL(`${backendUrl}/dms/frontend`);
+    frontendUrl.searchParams.set("renderer", "vue");
+    frontendUrl.searchParams.set("rendererVersion", "3");
+    if (clientUrl) {
+        frontendUrl.searchParams.set("clientUrl", clientUrl);
+    }
+    const response = await fetch(frontendUrl, {
+        headers: (0, workspace_1.bootstrapHeaders)(bootstrapSecret),
+    });
+    if ((0, workspace_1.isUnauthorized)(response.status)) {
+        throw new ManifestUnauthorizedError(frontendUrl.href, response.status);
+    }
+    if (!response.ok) {
+        throw new Error(`Failed to fetch manifest from ${frontendUrl.href} (${response.status})`);
+    }
+    const manifest = (await response.json());
+    if (manifest.version !== workspace_1.FRONTEND_MANIFEST_VERSION) {
+        throw new Error(`Unsupported frontend manifest version: ${String(manifest.version)}`);
+    }
+    const incompatible = manifest.modules.filter((module) => module.renderer?.name !== "vue" || module.renderer?.version !== "3");
+    if (incompatible.length) {
+        throw new Error(`Frontend manifest contains incompatible renderer modules: ${incompatible.map((module) => module.name).join(", ")}`);
+    }
+    return { pack: manifest.archive, modules: manifest.modules };
+}
+const MANIFEST_CACHE_FILE = ".manifest-cache.json";
+function readCachedManifest(workspaceDir) {
+    const file = (0, node_path_1.join)(workspaceDir, MANIFEST_CACHE_FILE);
+    if (!(0, node_fs_1.existsSync)(file))
+        return undefined;
+    try {
+        const parsed = JSON.parse((0, node_fs_1.readFileSync)(file, "utf-8"));
+        if (!parsed?.manifest)
+            return undefined;
+        return parsed;
+    }
+    catch {
+        return undefined;
+    }
+}
+function writeCachedManifest(workspaceDir, manifest) {
+    const entry = {
+        manifest,
+        fetchedAt: new Date().toISOString(),
+    };
+    (0, config_1.writeSecretBearingFile)((0, node_path_1.join)(workspaceDir, MANIFEST_CACHE_FILE), `${JSON.stringify(entry, null, 2)}\n`);
+}
+async function resolveManifest(workspaceDir, backendUrl, offline, clientUrl, bootstrapSecret) {
+    if (!offline) {
+        try {
+            const manifest = await fetchManifest(backendUrl, clientUrl, bootstrapSecret);
+            writeCachedManifest(workspaceDir, manifest);
+            return { manifest, fromCache: false };
+        }
+        catch (err) {
+            if (err instanceof ManifestUnauthorizedError)
+                throw err;
+            const cached = readCachedManifest(workspaceDir);
+            if (!cached)
+                throw err;
+            return fromCachedEntry(cached);
+        }
+    }
+    const cached = readCachedManifest(workspaceDir);
+    if (!cached) {
+        throw new Error("No cached manifest for this workspace — run once with the backend reachable before using --offline.");
+    }
+    return fromCachedEntry(cached);
+}
+function fromCachedEntry(cached) {
+    return {
+        manifest: cached.manifest,
+        fromCache: true,
+        fetchedAt: cached.fetchedAt,
+    };
+}
+function assertCachedLayerPathsExist(modules, fetchedAt) {
+    const missing = modules.filter((mod) => !(0, node_fs_1.existsSync)(mod.path));
+    if (missing.length === 0)
+        return;
+    throw new Error(`Cached manifest${fetchedAt ? ` (fetched ${fetchedAt})` : ""} references layer paths that no longer exist:\n` +
+        missing.map((mod) => `  - ${mod.name}: ${mod.path}`).join("\n") +
+        "\nStart the backend and re-run to refresh the cache.");
+}

package/dist/materialize.js

@@ -0,0 +1,249 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPackageRoot = getPackageRoot;
+exports.copyStaticTemplates = copyStaticTemplates;
+exports.writeWorkspacePackageJson = writeWorkspacePackageJson;
+exports.materializeLayers = materializeLayers;
+exports.createFrontendModuleRegistry = createFrontendModuleRegistry;
+exports.writeFrontendModuleRegistry = writeFrontendModuleRegistry;
+exports.writeDmsMainCss = writeDmsMainCss;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const config_1 = require("./config");
+const layers_1 = require("./layers");
+const fs_sync_1 = require("./fs-sync");
+function getPackageRoot() {
+    return (0, node_path_1.resolve)(__dirname, "..");
+}
+function getTemplateDir() {
+    return (0, node_path_1.join)(getPackageRoot(), "templates", "vue");
+}
+function copyTemplateFile(sourceName, destName, workspaceDir) {
+    const src = (0, node_path_1.join)(getTemplateDir(), sourceName);
+    if (!(0, node_fs_1.existsSync)(src)) {
+        throw new Error(`Template not found: ${src}`);
+    }
+    const destination = (0, node_path_1.join)(workspaceDir, destName);
+    (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(destination), { recursive: true });
+    if ((0, node_fs_1.statSync)(src).isDirectory()) {
+        (0, node_fs_1.cpSync)(src, destination, { recursive: true });
+        return;
+    }
+    (0, node_fs_1.copyFileSync)(src, destination);
+}
+function copyStaticTemplates(workspaceDir) {
+    for (const [sourceName, destName] of config_1.TEMPLATE_FILES) {
+        copyTemplateFile(sourceName, destName, workspaceDir);
+    }
+}
+function writeWorkspacePackageJson(workspaceDir, layers) {
+    const templatePath = (0, node_path_1.join)(getTemplateDir(), "package.json");
+    const pkg = JSON.parse((0, node_fs_1.readFileSync)(templatePath, "utf-8"));
+    pkg.dependencies ??= {};
+    for (const layer of layers) {
+        if (!layer.packageName)
+            continue;
+        pkg.dependencies[layer.packageName] = "workspace:*";
+    }
+    (0, node_fs_1.writeFileSync)((0, node_path_1.join)(workspaceDir, "package.json"), `${JSON.stringify(pkg, null, 2)}\n`);
+}
+function materializeLayers(workspaceDir, layers) {
+    const layersRoot = (0, node_path_1.join)(workspaceDir, config_1.LAYERS_SUBDIR);
+    if ((0, node_fs_1.existsSync)(layersRoot)) {
+        (0, node_fs_1.rmSync)(layersRoot, { recursive: true, force: true });
+    }
+    (0, node_fs_1.mkdirSync)(layersRoot, { recursive: true });
+    for (const layer of layers) {
+        if (!layer.packageName)
+            continue;
+        const dest = (0, layers_1.getLayerWorkspacePath)(workspaceDir, layer);
+        copyLayerSource(layer.path, dest);
+    }
+}
+function copyLayerSource(src, dest) {
+    (0, node_fs_1.cpSync)(src, dest, {
+        recursive: true,
+        dereference: true,
+        filter: (srcPath) => !(0, fs_sync_1.isBlocklistedCopyPath)(src, srcPath),
+    });
+    sanitizeLayerPackage((0, node_path_1.join)(dest, "package.json"));
+}
+function sanitizeLayerPackage(pkgPath) {
+    if (!(0, node_fs_1.existsSync)(pkgPath))
+        return;
+    (0, fs_sync_1.applyContent)((0, fs_sync_1.sanitizedPackageContent)((0, node_fs_1.readFileSync)(pkgPath, "utf-8")), pkgPath);
+}
+const GENERATED_MODULE_ID = /^[A-Za-z0-9_-]+$/;
+function validateFrontendModuleRegistry(registry, workspaceDir) {
+    const ids = new Set();
+    const moduleRoot = `${(0, node_path_1.resolve)(workspaceDir, config_1.LAYERS_SUBDIR)}${node_path_1.sep}`;
+    for (const module of registry.modules) {
+        if (!GENERATED_MODULE_ID.test(module.id) || ids.has(module.id))
+            throw new Error(`Invalid or duplicate frontend module id: ${module.id}`);
+        if (!Number.isFinite(module.priority))
+            throw new Error(`Invalid frontend module priority: ${module.id}`);
+        if (module.entry !== undefined && module.entry !== config_1.FRONTEND_MODULE_ENTRY)
+            throw new Error(`Invalid frontend module entry: ${module.id}`);
+        if (!(0, node_path_1.resolve)(module.root).startsWith(moduleRoot))
+            throw new Error(`Frontend module root escapes the workspace: ${module.id}`);
+        ids.add(module.id);
+    }
+}
+function createFrontendModuleRegistry(workspaceDir, layers) {
+    const modules = layers.map((layer) => {
+        const sourceEntry = (0, node_path_1.join)(layer.path, config_1.FRONTEND_MODULE_ENTRY);
+        const options = layer.options ?? {};
+        return {
+            id: (0, layers_1.getLayerSafeName)(layer),
+            packageName: layer.packageName,
+            root: (0, layers_1.getLayerWorkspacePath)(workspaceDir, layer),
+            priority: layer.priority ?? 0,
+            entry: (0, node_fs_1.existsSync)(sourceEntry) ? config_1.FRONTEND_MODULE_ENTRY : undefined,
+            options: layer.configKey ? { [layer.configKey]: options } : options,
+        };
+    });
+    modules.sort((left, right) => right.priority - left.priority || left.id.localeCompare(right.id));
+    const registry = { modules };
+    validateFrontendModuleRegistry(registry, workspaceDir);
+    return registry;
+}
+function writeFrontendModuleRegistry(workspaceDir, layers) {
+    const registry = createFrontendModuleRegistry(workspaceDir, layers);
+    (0, node_fs_1.writeFileSync)((0, node_path_1.join)(workspaceDir, "generated-frontend-modules.json"), `${JSON.stringify(registry, null, 2)}\n`);
+    writeFrontendTypePaths(workspaceDir, registry);
+    writeFrontendModuleLoader(workspaceDir, registry);
+    writeLocaleMessages(workspaceDir, registry);
+    writeShortcutExports(workspaceDir, registry);
+    writePublicAssets(workspaceDir, registry);
+}
+function writeFrontendTypePaths(workspaceDir, registry) {
+    const paths = {
+        "#dms-inertia/frontend-module": ["./frontend-module.ts"],
+        "@frontend/*": ["./frontend-modules/*"],
+    };
+    [...registry.modules].reverse().forEach((module) => {
+        const layersRoot = (0, node_path_1.join)(module.root, "layers");
+        if (!(0, node_fs_1.existsSync)(layersRoot))
+            return;
+        (0, node_fs_1.readdirSync)(layersRoot).forEach((name) => {
+            paths[`#${name}/*`] = [
+                `./frontend-modules/${module.id}/layers/${name}/*`,
+            ];
+        });
+    });
+    const config = { compilerOptions: { paths } };
+    (0, node_fs_1.writeFileSync)((0, node_path_1.join)(workspaceDir, "frontend-paths.generated.json"), `${JSON.stringify(config, null, 2)}\n`);
+}
+function writeFrontendModuleLoader(workspaceDir, registry) {
+    const modules = registry.modules.filter((module) => module.entry);
+    const imports = modules
+        .map((module, index) => `import module${index} from "@frontend/${module.id}/${module.entry}";`)
+        .join("\n");
+    const registrations = modules
+        .map((module, index) => `{ module: module${index}, options: { public: ${JSON.stringify(module.options)} } }`)
+        .join(", ");
+    const content = `${imports}\n\nimport type { DmsFrontendModuleRegistration } from "./frontend-module";\n\nexport const frontendModules: DmsFrontendModuleRegistration[] = [${registrations}];\n`;
+    (0, node_fs_1.writeFileSync)((0, node_path_1.join)(workspaceDir, "frontend-modules.generated.ts"), content);
+}
+function moduleAssetRoots(moduleRoot) {
+    const layersRoot = (0, node_path_1.join)(moduleRoot, "layers");
+    if (!(0, node_fs_1.existsSync)(layersRoot)) {
+        return [{ absolutePath: moduleRoot, relativePrefix: "" }];
+    }
+    return (0, node_fs_1.readdirSync)(layersRoot).map((name) => ({
+        absolutePath: (0, node_path_1.join)(layersRoot, name),
+        relativePrefix: `layers/${name}/`,
+    }));
+}
+function writePublicAssets(workspaceDir, registry) {
+    const destination = (0, node_path_1.join)(workspaceDir, "public");
+    (0, node_fs_1.rmSync)(destination, { force: true, recursive: true });
+    for (const module of [...registry.modules].reverse()) {
+        for (const root of moduleAssetRoots(module.root)) {
+            const source = (0, node_path_1.join)(root.absolutePath, "public");
+            if ((0, node_fs_1.existsSync)(source)) {
+                (0, node_fs_1.cpSync)(source, destination, { force: true, recursive: true });
+            }
+        }
+    }
+}
+function discoverAssets(registry, directory, extensions) {
+    return registry.modules.flatMap((module) => {
+        return moduleAssetRoots(module.root).flatMap((assetRoot) => {
+            const root = (0, node_path_1.join)(assetRoot.absolutePath, directory);
+            return (0, fs_sync_1.collectFiles)(root)
+                .filter((file) => extensions.some((extension) => file.endsWith(extension)))
+                .sort()
+                .map((relativePath) => ({
+                moduleId: module.id,
+                relativePath: `${assetRoot.relativePrefix}${(0, node_path_1.join)(directory, relativePath).split(node_path_1.sep).join("/")}`,
+            }));
+        });
+    });
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function mergeLocaleMessages(source, existing) {
+    const merged = { ...source };
+    for (const [key, value] of Object.entries(existing)) {
+        const sourceValue = merged[key];
+        merged[key] =
+            isRecord(sourceValue) && isRecord(value)
+                ? mergeLocaleMessages(sourceValue, value)
+                : value;
+    }
+    return merged;
+}
+function readLocaleMessages(assets, registry) {
+    const roots = new Map(registry.modules.map((module) => [module.id, module.root]));
+    const messages = {};
+    for (const asset of assets) {
+        const locale = asset.relativePath.match(/(?:^|[/-])([a-z]{2})-[A-Z]{2}\.json$/)?.[1];
+        const root = roots.get(asset.moduleId);
+        if (!locale || !root)
+            continue;
+        const value = JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.join)(root, asset.relativePath), "utf8"));
+        messages[locale] = mergeLocaleMessages(value, messages[locale] ?? {});
+    }
+    return messages;
+}
+function writeLocaleMessages(workspaceDir, registry) {
+    const locales = discoverAssets(registry, "i18n/locales", [".json"]);
+    const messages = readLocaleMessages(locales, registry);
+    const outputDir = (0, node_path_1.join)(workspaceDir, "locales.generated");
+    (0, node_fs_1.rmSync)(outputDir, { recursive: true, force: true });
+    (0, node_fs_1.mkdirSync)(outputDir, { recursive: true });
+    for (const [locale, value] of Object.entries(messages)) {
+        (0, node_fs_1.writeFileSync)((0, node_path_1.join)(outputDir, `${locale}.json`), JSON.stringify(value));
+        (0, node_fs_1.writeFileSync)((0, node_path_1.join)(outputDir, `${locale}.ts`), `const messages = ${JSON.stringify(value)};\nexport default messages;\n`);
+    }
+    const supportedLocales = Object.keys(messages);
+    (0, node_fs_1.writeFileSync)((0, node_path_1.join)(workspaceDir, "email-locales.generated.json"), JSON.stringify(supportedLocales));
+    const loaders = supportedLocales
+        .filter((locale) => locale !== "en")
+        .map((locale) => `${JSON.stringify(locale)}: () => import(${JSON.stringify(`./locales.generated/${locale}`)})`);
+    (0, node_fs_1.writeFileSync)((0, node_path_1.join)(workspaceDir, "locales.generated.ts"), `import defaultMessages from "./locales.generated/en";\ninterface LocaleModule { default: Record<string, unknown>; }\ntype LocaleLoader = () => Promise<LocaleModule>;\nexport const supportedLocales = ${JSON.stringify(supportedLocales)};\nexport const localeMessages: Record<string, Record<string, unknown>> = { en: defaultMessages };\nconst localeLoaders: Record<string, LocaleLoader> = { ${loaders.join(", ")} };\nexport async function loadLocaleMessages(locale: string): Promise<Record<string, unknown>> {\n  const normalized = locale.slice(0, 2);\n  const existing = localeMessages[normalized];\n  if (existing) return existing;\n  const loader = localeLoaders[normalized];\n  if (!loader) return defaultMessages;\n  const messages = (await loader()).default;\n  localeMessages[normalized] = messages;\n  return messages;\n}\n`);
+}
+function writeShortcutExports(workspaceDir, registry) {
+    const registries = discoverAssets(registry, "app/config", [
+        "shortcuts-registry.ts",
+        "shortcuts-registry.js",
+    ]);
+    const imports = registries.map((asset, index) => `import registry${index} from "@frontend/${asset.moduleId}/${asset.relativePath}";`);
+    const spreads = registries.map((_, index) => `...registry${index}`);
+    const content = `${imports.join("\n")}\nconst aggregatedShortcuts = [${spreads.join(", ")}];\nexport { aggregatedShortcuts };\nexport default aggregatedShortcuts;\n`;
+    (0, node_fs_1.writeFileSync)((0, node_path_1.join)(workspaceDir, "shortcuts-aggregated.generated.ts"), content);
+}
+function writeDmsMainCss(workspaceDir, layers) {
+    const sources = layers
+        .map((layer) => `@source "${(0, layers_1.getLayerWorkspacePath)(workspaceDir, layer)}/${config_1.TAILWIND_SOURCE_GLOB}";`)
+        .join("\n");
+    const content = `@import "tailwindcss";
+@import "@nuxt/ui";
+@plugin "@tailwindcss/typography";
+
+${sources}
+`;
+    (0, node_fs_1.writeFileSync)((0, node_path_1.join)(workspaceDir, "dms-main.css"), content);
+}

package/dist/ports.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PORT_FALLBACK_RANGE = void 0;
+exports.reserveFreePort = reserveFreePort;
+const node_net_1 = require("node:net");
+exports.PORT_FALLBACK_RANGE = 20;
+const MAX_TCP_PORT = 65535;
+function tryListen(port) {
+    return new Promise((resolve) => {
+        const server = (0, node_net_1.createServer)();
+        server.unref();
+        server.once("error", () => resolve(undefined));
+        server.listen({ port }, () => resolve(server));
+    });
+}
+async function reserveFreePort(preferred, range = exports.PORT_FALLBACK_RANGE) {
+    const end = Math.min(preferred + range, MAX_TCP_PORT);
+    for (let port = preferred; port <= end; port++) {
+        const server = await tryListen(port);
+        if (server) {
+            return {
+                port,
+                release: () => new Promise((resolve) => {
+                    server.close(() => resolve());
+                }),
+            };
+        }
+    }
+    throw new Error(`No free port found between ${preferred} and ${end}.`);
+}

package/dist/update-check.js

@@ -0,0 +1,173 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NO_UPDATE_CHECK_FLAG = exports.UPDATE_CHECK_TIMEOUT_MS = exports.UPDATE_CHECK_INTERVAL_MS = exports.UPDATE_CHECK_PACKAGE = void 0;
+exports.stripUpdateCheckFlag = stripUpdateCheckFlag;
+exports.isUpdateCheckEnabled = isUpdateCheckEnabled;
+exports.updateCheckCacheFile = updateCheckCacheFile;
+exports.fetchLatestVersionFromRegistry = fetchLatestVersionFromRegistry;
+exports.checkForUpdate = checkForUpdate;
+const node_fs_1 = require("node:fs");
+const node_http_1 = require("node:http");
+const node_https_1 = require("node:https");
+const node_path_1 = require("node:path");
+const semver_1 = __importDefault(require("semver"));
+const config_1 = require("./config");
+exports.UPDATE_CHECK_PACKAGE = "@antelopejs/dms-frontend";
+const DEFAULT_REGISTRY_URL = "https://registry.npmjs.org/";
+exports.UPDATE_CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;
+exports.UPDATE_CHECK_TIMEOUT_MS = 3000;
+exports.NO_UPDATE_CHECK_FLAG = "--no-update-check";
+const HELP_OR_VERSION_FLAGS = ["--help", "-h", "--version", "-v"];
+const VALUE_TAKING_OPTIONS = [
+    "-b",
+    "--backend-url",
+    "-p",
+    "--port",
+    "--bootstrap-secret",
+    "-l",
+    "--layer",
+    "-m",
+    "--module",
+    "--local-package",
+];
+function flagIndexes(argv, flags) {
+    const terminator = argv.indexOf("--");
+    const end = terminator === -1 ? argv.length : terminator;
+    const found = [];
+    for (let index = 0; index < end; index++) {
+        if (!flags.includes(argv[index]))
+            continue;
+        if (VALUE_TAKING_OPTIONS.includes(argv[index - 1] ?? ""))
+            continue;
+        found.push(index);
+    }
+    return found;
+}
+function stripUpdateCheckFlag(argv) {
+    const dropped = new Set(flagIndexes(argv, [exports.NO_UPDATE_CHECK_FLAG]));
+    return argv.filter((_, index) => !dropped.has(index));
+}
+function isUpdateCheckEnabled(argv, env) {
+    if (env.CI)
+        return false;
+    if (env.NO_UPDATE_NOTIFIER)
+        return false;
+    if (argv[0] === "help")
+        return false;
+    if (flagIndexes(argv, [exports.NO_UPDATE_CHECK_FLAG]).length)
+        return false;
+    return flagIndexes(argv, HELP_OR_VERSION_FLAGS).length === 0;
+}
+function updateCheckCacheFile() {
+    return (0, node_path_1.join)(config_1.DMS_FRONTEND_HOME, "update-check.json");
+}
+function readCache(file) {
+    try {
+        const parsed = JSON.parse((0, node_fs_1.readFileSync)(file, "utf-8"));
+        if (typeof parsed?.checkedAt !== "number")
+            return undefined;
+        const latestVersion = parsed.latestVersion;
+        if (latestVersion !== undefined && typeof latestVersion !== "string") {
+            return undefined;
+        }
+        return { checkedAt: parsed.checkedAt, latestVersion };
+    }
+    catch {
+        return undefined;
+    }
+}
+function writeCache(file, cache) {
+    try {
+        (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(file), { recursive: true });
+        (0, node_fs_1.writeFileSync)(file, `${JSON.stringify(cache)}\n`);
+    }
+    catch {
+    }
+}
+function fetchLatestVersionFromRegistry(packageName, registryUrl = DEFAULT_REGISTRY_URL, timeoutMs = exports.UPDATE_CHECK_TIMEOUT_MS) {
+    return new Promise((resolve) => {
+        let request;
+        let deadline;
+        let settled = false;
+        const settle = (version) => {
+            if (settled)
+                return;
+            settled = true;
+            if (deadline)
+                clearTimeout(deadline);
+            resolve(version);
+        };
+        try {
+            const url = new URL(`${packageName.replace("/", "%2f")}/latest`, registryUrl.endsWith("/") ? registryUrl : `${registryUrl}/`);
+            const get = url.protocol === "http:" ? node_http_1.get : node_https_1.get;
+            request = get(url, { headers: { accept: "application/json" } }, (response) => {
+                if (response.statusCode !== 200) {
+                    response.resume();
+                    settle();
+                    return;
+                }
+                response.setEncoding("utf-8");
+                let body = "";
+                response.on("data", (chunk) => {
+                    body += chunk;
+                });
+                response.on("end", () => {
+                    try {
+                        const version = JSON.parse(body)?.version;
+                        settle(typeof version === "string" ? version : undefined);
+                    }
+                    catch {
+                        settle();
+                    }
+                });
+                response.on("error", () => settle());
+            });
+            request.on("socket", (socket) => socket.unref());
+            request.on("error", () => settle());
+            deadline = setTimeout(() => {
+                request?.destroy();
+                settle();
+            }, timeoutMs);
+            deadline.unref();
+        }
+        catch {
+            settle();
+        }
+    });
+}
+function formatNotice(currentVersion, latestVersion) {
+    return (`A newer DMS frontend version is available: ${currentVersion} -> ${latestVersion}. ` +
+        "Run `ajs update dms` to update.\n");
+}
+function isNewer(currentVersion, latestVersion) {
+    const current = semver_1.default.valid(currentVersion);
+    const latest = semver_1.default.valid(latestVersion);
+    if (!current || !latest)
+        return false;
+    return semver_1.default.lt(current, latest);
+}
+async function checkForUpdate(options) {
+    try {
+        const { currentVersion, argv = process.argv.slice(2), env = process.env, now = Date.now, cacheFile = updateCheckCacheFile(), fetchLatestVersion = fetchLatestVersionFromRegistry, write = (message) => process.stderr.write(message), } = options;
+        if (!isUpdateCheckEnabled(argv, env))
+            return;
+        const cached = readCache(cacheFile);
+        const checkedAt = now();
+        const withinInterval = cached !== undefined &&
+            checkedAt - cached.checkedAt < exports.UPDATE_CHECK_INTERVAL_MS;
+        let latestVersion = cached?.latestVersion;
+        if (!withinInterval) {
+            latestVersion =
+                (await fetchLatestVersion(exports.UPDATE_CHECK_PACKAGE)) ?? latestVersion;
+            writeCache(cacheFile, { checkedAt, latestVersion });
+        }
+        if (latestVersion && isNewer(currentVersion, latestVersion)) {
+            write(formatNotice(currentVersion, latestVersion));
+        }
+    }
+    catch {
+    }
+}