@antelopejs/dms-frontend 0.0.1

package/dist/utils/cli-ui.js

@@ -0,0 +1,178 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Spinner = void 0;
+exports.displayBox = displayBox;
+exports.displayBanner = displayBanner;
+exports.success = success;
+exports.error = error;
+exports.warning = warning;
+exports.info = info;
+exports.header = header;
+exports.keyValue = keyValue;
+const boxen_1 = __importDefault(require("boxen"));
+const chalk_1 = __importDefault(require("chalk"));
+const figlet_1 = __importDefault(require("figlet"));
+const clearLine = () => process.stdout.write("\r\x1b[K");
+const spinnerChars = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+const SPINNER_INTERVAL_MS = 80;
+function isTerminalOutput() {
+    return process.stdout.isTTY ?? false;
+}
+class Spinner {
+    constructor(text) {
+        this.isRunning = false;
+        this.currentCharIndex = 0;
+        this.isTerminal = isTerminalOutput();
+        this.text = text;
+    }
+    async start(text) {
+        if (text) {
+            this.text = text;
+        }
+        if (this.isRunning) {
+            return this;
+        }
+        this.isRunning = true;
+        this.currentCharIndex = 0;
+        if (!this.isTerminal) {
+            console.log(`  ${this.text}`);
+            return this;
+        }
+        this.interval = setInterval(() => {
+            if (this.isRunning) {
+                const spinnerChar = spinnerChars[this.currentCharIndex];
+                process.stdout.write(`\r${chalk_1.default.cyan(spinnerChar)} ${this.text}`);
+                this.currentCharIndex =
+                    (this.currentCharIndex + 1) % spinnerChars.length;
+            }
+        }, SPINNER_INTERVAL_MS);
+        return this;
+    }
+    update(text) {
+        this.text = text;
+        return this;
+    }
+    log(stream, message) {
+        if (this.isRunning && this.isTerminal) {
+            clearLine();
+            stream.write(`${message}\n`);
+            const spinnerChar = spinnerChars[this.currentCharIndex];
+            process.stdout.write(`${chalk_1.default.cyan(spinnerChar)} ${this.text}`);
+        }
+        else {
+            stream.write(`${message}\n`);
+        }
+        return this;
+    }
+    async succeed(text) {
+        if (!this.isRunning)
+            return;
+        await this.stop();
+        const message = text || this.text;
+        if (this.isTerminal) {
+            process.stdout.write(`\r${chalk_1.default.bold.green("✓")} ${message}\n`);
+        }
+        else {
+            console.log(`✓ ${message}`);
+        }
+    }
+    async fail(text) {
+        if (!this.isRunning)
+            return;
+        await this.stop();
+        const message = text || this.text;
+        if (this.isTerminal) {
+            process.stdout.write(`\r${chalk_1.default.bold.red("✗")} ${chalk_1.default.red(message)}\n`);
+        }
+        else {
+            console.log(`✗ ${message}`);
+        }
+    }
+    async info(text) {
+        if (!this.isRunning)
+            return;
+        await this.stop();
+        const message = text || this.text;
+        if (this.isTerminal) {
+            process.stdout.write(`\r${chalk_1.default.bold.blue("ℹ")} ${message}\n`);
+        }
+        else {
+            console.log(`ℹ ${message}`);
+        }
+    }
+    async warn(text) {
+        if (!this.isRunning)
+            return;
+        await this.stop();
+        const message = text || this.text;
+        if (this.isTerminal) {
+            process.stdout.write(`\r${chalk_1.default.bold.yellow("⚠")} ${message}\n`);
+        }
+        else {
+            console.log(`⚠ ${message}`);
+        }
+    }
+    async pause() {
+        if (this.interval) {
+            clearInterval(this.interval);
+            this.interval = undefined;
+        }
+        if (this.isTerminal) {
+            clearLine();
+        }
+    }
+    async stop() {
+        if (this.interval) {
+            clearInterval(this.interval);
+            this.interval = undefined;
+        }
+        this.isRunning = false;
+        if (this.isTerminal) {
+            clearLine();
+        }
+    }
+    async clear() {
+        await this.stop();
+    }
+}
+exports.Spinner = Spinner;
+function displayBox(message, title, options) {
+    const defaultOptions = {
+        padding: 1,
+        margin: 1,
+        borderStyle: "round",
+        borderColor: "blue",
+        title: title,
+        titleAlignment: "center",
+    };
+    console.log((0, boxen_1.default)(message, { ...defaultOptions, ...options }));
+}
+function displayBanner(text, font) {
+    const figletText = figlet_1.default.textSync(text, {
+        font: (font || "Standard"),
+    });
+    console.log(chalk_1.default.blue(figletText));
+}
+function success(message) {
+    console.log(`${chalk_1.default.green.bold("✓")} ${message}`);
+}
+function error(message) {
+    console.log(`${chalk_1.default.red.bold("✗")} ${chalk_1.default.red(message)}`);
+}
+function warning(message) {
+    console.log(`${chalk_1.default.yellow.bold("⚠")} ${chalk_1.default.yellow(message)}`);
+}
+function info(message) {
+    console.log(`${chalk_1.default.blue.bold("ℹ")} ${message}`);
+}
+function header(text) {
+    console.log("");
+    console.log(chalk_1.default.bold.blue(text));
+    console.log(chalk_1.default.blue("─".repeat(text.length)));
+}
+function keyValue(key, value) {
+    return `${chalk_1.default.cyan(key)}: ${value}`;
+}

package/dist/verify-source-runner.js

@@ -0,0 +1,228 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const strict_1 = __importDefault(require("node:assert/strict"));
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = require("node:fs");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const common_1 = require("./common");
+function removeDevelopmentDependencies(root) {
+    const packagePath = (0, node_path_1.join)(root, "package.json");
+    if (!(0, node_fs_1.existsSync)(packagePath))
+        return;
+    const packageData = JSON.parse((0, node_fs_1.readFileSync)(packagePath, "utf8"));
+    delete packageData.devDependencies;
+    (0, node_fs_1.writeFileSync)(packagePath, `${JSON.stringify(packageData, null, 2)}\n`);
+}
+if (!process.env.DMS_LAYER_SOURCE)
+    throw new Error("DMS_LAYER_SOURCE must identify a frontend package");
+const sourceRoot = (0, node_path_1.resolve)(process.env.DMS_LAYER_SOURCE);
+const workspace = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "dms-inertia-real-source-"));
+const templateRoot = (0, node_path_1.join)((0, common_1.getPackageRoot)(), "templates", "vue");
+const commandEnvironment = { ...process.env };
+const EMAIL_BUILD_SIZE_CEILING_BYTES = 256 * 1024;
+const NON_EMAIL_RUNTIME_PATTERN = /DisplayRichText|ApexCharts|Tiptap|FlowCanvas|app\/.*table|components\/table/i;
+delete commandEnvironment.NODE_OPTIONS;
+const templateFiles = (0, node_fs_1.readdirSync)(templateRoot).filter((file) => !file.startsWith("npmrc"));
+for (const file of templateFiles)
+    (0, node_fs_1.cpSync)((0, node_path_1.join)(templateRoot, file), (0, node_path_1.join)(workspace, file), { recursive: true });
+const extraSources = JSON.parse(process.env.DMS_MODULE_SOURCES ?? "[]");
+const roots = [
+    ...((0, node_fs_1.existsSync)((0, node_path_1.join)(sourceRoot, "dms.frontend.ts"))
+        ? [sourceRoot]
+        : (0, node_fs_1.readdirSync)(sourceRoot).map((directory) => (0, node_path_1.join)(sourceRoot, directory))),
+    ...extraSources.map((root) => (0, node_path_1.resolve)(root)),
+];
+const layers = roots.map((root) => ({
+    path: root,
+    packageName: JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.join)(root, "package.json"), "utf8"))
+        .name,
+}));
+(0, common_1.materializeLayers)(workspace, layers);
+const registry = (0, common_1.createFrontendModuleRegistry)(workspace, layers);
+registry.modules.forEach((module) => {
+    removeDevelopmentDependencies(module.root);
+});
+(0, common_1.writeFrontendModuleRegistry)(workspace, layers);
+(0, node_fs_1.writeFileSync)((0, node_path_1.join)(workspace, "dms-main.css"), '@import "tailwindcss";\n@import "@nuxt/ui";\n');
+(0, common_1.writeWorkspacePackageJson)(workspace, layers);
+const packagePath = (0, node_path_1.join)(workspace, "package.json");
+const workspacePackage = JSON.parse((0, node_fs_1.readFileSync)(packagePath, "utf8"));
+const localPackages = JSON.parse(process.env.DMS_LOCAL_PACKAGES ?? "{}");
+workspacePackage.pnpm = {
+    overrides: {
+        ...Object.fromEntries(layers.map((layer) => [layer.packageName, "workspace:*"])),
+        ...Object.fromEntries(Object.entries(localPackages).map(([name, path]) => [
+            name,
+            `link:${(0, node_path_1.resolve)(path)}`,
+        ])),
+    },
+};
+(0, node_fs_1.writeFileSync)(packagePath, `${JSON.stringify(workspacePackage, null, 2)}\n`);
+process.stdout.write(`Generated workspace: ${workspace}\n`);
+(0, node_child_process_1.execFileSync)("pnpm", ["install", "--ignore-scripts"], {
+    cwd: workspace,
+    env: commandEnvironment,
+    stdio: "inherit",
+});
+(0, node_child_process_1.execFileSync)("pnpm", ["run", "build"], {
+    cwd: workspace,
+    env: commandEnvironment,
+    stdio: "inherit",
+});
+const typecheckArguments = [
+    "--import",
+    "./typecheck-loader.mjs",
+    "./node_modules/vue-tsc/bin/vue-tsc.js",
+    "--noEmit",
+];
+const typecheckCommand = process.platform === "win32" ? process.execPath : "env";
+const typecheckCommandArguments = process.platform === "win32"
+    ? typecheckArguments
+    : ["-u", "NODE_OPTIONS", process.execPath, ...typecheckArguments];
+(0, node_child_process_1.execFileSync)(typecheckCommand, typecheckCommandArguments, {
+    cwd: workspace,
+    env: commandEnvironment,
+    stdio: "inherit",
+});
+const clientRoot = (0, node_path_1.join)(workspace, "dist", "client");
+const manifest = JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.join)(clientRoot, ".vite", "manifest.json"), "utf8"));
+const mainEntry = Object.values(manifest).find((entry) => entry.isEntry);
+strict_1.default.ok(mainEntry, "Vite manifest must identify the main entry");
+const mainJavascript = (0, node_fs_1.readFileSync)((0, node_path_1.join)(clientRoot, mainEntry.file), "utf8");
+const javascript = (0, node_fs_1.readdirSync)((0, node_path_1.join)(clientRoot, "assets"))
+    .filter((file) => file.endsWith(".js"))
+    .map((file) => (0, node_fs_1.readFileSync)((0, node_path_1.join)(clientRoot, "assets", file), "utf8"))
+    .join("\n");
+strict_1.default.ok(Object.keys(manifest).length > 0, "Vite manifest must contain reachable entries");
+strict_1.default.doesNotMatch(mainJavascript, /ApexCharts|tiptap/i);
+strict_1.default.match(javascript, /ApexCharts/);
+strict_1.default.match(javascript, /tiptap/i);
+strict_1.default.ok(Object.keys(manifest).some((source) => source.endsWith("/kpi/KpiCard.vue")), "DmsKpiCard must be reachable at runtime");
+const emailRoot = (0, node_path_1.join)(workspace, "dist", "server");
+const emailManifestContent = (0, node_fs_1.readFileSync)((0, node_path_1.join)(emailRoot, ".vite", "manifest.json"), "utf8");
+strict_1.default.doesNotMatch(emailManifestContent, NON_EMAIL_RUNTIME_PATTERN);
+const emailManifest = JSON.parse(emailManifestContent);
+const emailJavascriptFiles = [
+    ...new Set([
+        "email-renderer.js",
+        ...Object.values(emailManifest)
+            .map((entry) => entry.file)
+            .filter((file) => file.endsWith(".js")),
+    ]),
+];
+const emailJavascript = emailJavascriptFiles
+    .map((file) => (0, node_fs_1.readFileSync)((0, node_path_1.join)(emailRoot, file), "utf8"))
+    .join("\n");
+strict_1.default.doesNotMatch(emailJavascript, NON_EMAIL_RUNTIME_PATTERN);
+const emailBuildSize = Buffer.byteLength(emailJavascript);
+const emailLocaleBytes = (0, node_fs_1.readdirSync)((0, node_path_1.join)(emailRoot, "locales")).reduce((total, file) => total + (0, node_fs_1.readFileSync)((0, node_path_1.join)(emailRoot, "locales", file)).byteLength, 0);
+process.stdout.write(`Email JavaScript: ${emailBuildSize} bytes; locale data: ${emailLocaleBytes} bytes\n`);
+strict_1.default.ok(emailBuildSize <= EMAIL_BUILD_SIZE_CEILING_BYTES, `Email build is ${emailBuildSize} bytes; ceiling is ${EMAIL_BUILD_SIZE_CEILING_BYTES}`);
+const emailCases = [
+    {
+        name: "EmailAdminInvite",
+        props: {
+            userName: "Ada",
+            signupLink: "https://example.test/join",
+            expiresIn: "1 hour",
+        },
+        marker: "Ada",
+    },
+    {
+        name: "EmailExportReady",
+        props: {
+            userName: "Ada",
+            downloadLink: "https://example.test/export",
+            fileName: "users.csv",
+            fileSize: "1 KB",
+            expiresIn: "1 hour",
+        },
+        marker: "users.csv",
+    },
+    {
+        name: "EmailResetPassword",
+        props: { userName: "Ada", resetCode: "123456", expiresIn: "1 hour" },
+        marker: "123456",
+    },
+    {
+        name: "EmailTwoFactor",
+        props: { userName: "Ada", verificationCode: "654321" },
+        marker: "654321",
+    },
+    {
+        name: "EmailUserValidation",
+        props: { userName: "Ada", validationCode: "112233", expiresIn: "1 hour" },
+        marker: "112233",
+    },
+    {
+        name: "EmailButton",
+        props: { href: "https://example.test", expiresIn: "1 hour" },
+        marker: "https://example.test",
+    },
+    {
+        name: "EmailLayout",
+        props: { title: "Contract title" },
+        marker: "Contract title",
+    },
+    {
+        name: "EmailOTP",
+        props: { code: "445566", expiresIn: "1 hour" },
+        marker: "445566",
+    },
+];
+async function verifyEmailContracts() {
+    const { renderEmail } = await Promise.resolve(`${(0, node_path_1.join)(workspace, "dist/server/email-renderer.js")}`).then(s => __importStar(require(s)));
+    for (const emailCase of emailCases) {
+        const html = await renderEmail(emailCase.name, emailCase.props);
+        strict_1.default.match(html, /^<!doctype html>/);
+        if (emailCase.name === "EmailLayout") {
+            strict_1.default.match(html, /<meta charset="utf-8"/);
+            strict_1.default.match(html, /images\/antelope-logo\/light\.svg/);
+            strict_1.default.doesNotMatch(html, /<h1[^>]*\bas=/);
+        }
+        strict_1.default.match(html, new RegExp(emailCase.marker.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")));
+    }
+}
+for (const marker of ["auth/login", "DefaultLayout", "error.500.title"]) {
+    strict_1.default.match(javascript, new RegExp(marker), `${marker} must be reachable at runtime`);
+}
+void verifyEmailContracts().then(() => {
+    process.stdout.write(`Real DMS source compiled in ${(0, node_path_1.basename)(workspace)}\n`);
+});

package/dist/workspace-setup.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeDepsHash = computeDepsHash;
+exports.needsInstall = needsInstall;
+exports.saveDepsHash = saveDepsHash;
+exports.installDeps = installDeps;
+exports.runCommand = runCommand;
+exports.setupWorkspace = setupWorkspace;
+const node_child_process_1 = require("node:child_process");
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const layers_1 = require("./layers");
+const manifest_1 = require("./manifest");
+const materialize_1 = require("./materialize");
+const workspace_1 = require("./workspace");
+const config_1 = require("./config");
+function computeDepsHash(layerPaths, workspacePackage) {
+    const hash = (0, node_crypto_1.createHash)("sha256");
+    if (workspacePackage && (0, node_fs_1.existsSync)(workspacePackage))
+        hash.update((0, node_fs_1.readFileSync)(workspacePackage));
+    for (const layerPath of [...layerPaths].sort()) {
+        const pkgPath = (0, node_path_1.join)(layerPath, "package.json");
+        if ((0, node_fs_1.existsSync)(pkgPath)) {
+            hash.update((0, node_fs_1.readFileSync)(pkgPath, "utf-8"));
+        }
+    }
+    return hash.digest("hex");
+}
+function needsInstall(workspaceDir, layerPaths, force) {
+    if (force)
+        return true;
+    const hashFile = (0, node_path_1.join)(workspaceDir, config_1.DEPS_HASH_FILE);
+    if (!(0, node_fs_1.existsSync)(hashFile))
+        return true;
+    if (!(0, node_fs_1.existsSync)((0, node_path_1.join)(workspaceDir, "node_modules")))
+        return true;
+    const currentHash = computeDepsHash(layerPaths, (0, node_path_1.join)(workspaceDir, "package.json"));
+    const savedHash = (0, node_fs_1.readFileSync)(hashFile, "utf-8").trim();
+    return currentHash !== savedHash;
+}
+function saveDepsHash(workspaceDir, layerPaths) {
+    const hash = computeDepsHash(layerPaths, (0, node_path_1.join)(workspaceDir, "package.json"));
+    (0, node_fs_1.writeFileSync)((0, node_path_1.join)(workspaceDir, config_1.DEPS_HASH_FILE), hash);
+}
+function installDeps(workspaceDir) {
+    const { execSync } = require("node:child_process");
+    execSync("pnpm install", {
+        cwd: workspaceDir,
+        stdio: "inherit",
+    });
+}
+function runCommand(command, args, options) {
+    return new Promise((resolve, reject) => {
+        const child = (0, node_child_process_1.spawn)(command, args, {
+            stdio: "inherit",
+            shell: true,
+            ...options,
+        });
+        child.on("error", (error) => reject(error));
+        child.on("exit", (code) => resolve(code || 0));
+    });
+}
+async function setupWorkspace(opts) {
+    const { backendUrl, force, mode, offline, clientUrl, bootstrapSecret } = opts;
+    const workspaceKey = opts.workspaceKey ?? (0, config_1.canonicalizeBackendUrl)(backendUrl);
+    const workspaceDir = (0, workspace_1.ensureWorkspace)(workspaceKey);
+    (0, workspace_1.writeWorkspaceMeta)(workspaceDir, backendUrl, workspaceKey);
+    const resolved = await (0, manifest_1.resolveManifest)(workspaceDir, backendUrl, !!offline, clientUrl, bootstrapSecret);
+    const { manifest, fromCache, fetchedAt } = resolved;
+    let layers;
+    if (mode === "dev") {
+        (0, layers_1.assertLayerPathsServed)(manifest.modules);
+        if (fromCache) {
+            (0, manifest_1.assertCachedLayerPathsExist)(manifest.modules, fetchedAt);
+        }
+        layers = (0, layers_1.buildLayersFromPaths)(manifest.modules);
+    }
+    else {
+        const cacheDir = (0, node_path_1.join)(workspaceDir, ".layers-cache");
+        if (fromCache) {
+            if (!(0, node_fs_1.existsSync)(cacheDir)) {
+                throw new Error("Backend unreachable and no previously downloaded layers archive — run once with the backend reachable first.");
+            }
+            (0, layers_1.assertCachedArchivesExist)(manifest.modules, cacheDir, fetchedAt);
+        }
+        else {
+            await (0, layers_1.downloadAndExtractLayers)(backendUrl, manifest.pack, cacheDir, force, bootstrapSecret);
+        }
+        layers = await (0, layers_1.buildLayersFromCache)(manifest.modules, cacheDir);
+    }
+    (0, materialize_1.copyStaticTemplates)(workspaceDir);
+    (0, materialize_1.writeWorkspacePackageJson)(workspaceDir, layers);
+    (0, materialize_1.materializeLayers)(workspaceDir, layers);
+    (0, materialize_1.writeFrontendModuleRegistry)(workspaceDir, layers);
+    (0, materialize_1.writeDmsMainCss)(workspaceDir, layers);
+    const layerPaths = layers.map((layer) => layer.path);
+    const shouldInstall = needsInstall(workspaceDir, layerPaths, force);
+    if (shouldInstall) {
+        installDeps(workspaceDir);
+        saveDepsHash(workspaceDir, layerPaths);
+    }
+    return {
+        workspaceDir,
+        layers,
+        manifestFromCache: fromCache,
+        manifestFetchedAt: fetchedAt,
+    };
+}

package/dist/workspace.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FRONTEND_MANIFEST_VERSION = void 0;
+exports.getWorkspaceDirForKey = getWorkspaceDirForKey;
+exports.projectWorkspaceKey = projectWorkspaceKey;
+exports.getWorkspaceDir = getWorkspaceDir;
+exports.ensureWorkspace = ensureWorkspace;
+exports.listWorkspaces = listWorkspaces;
+exports.writeWorkspaceMeta = writeWorkspaceMeta;
+exports.bootstrapHeaders = bootstrapHeaders;
+exports.isUnauthorized = isUnauthorized;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const config_1 = require("./config");
+const WORKSPACE_META_FILE = ".ajs-dms-meta.json";
+function getWorkspaceDirForKey(key) {
+    return (0, node_path_1.join)(config_1.DMS_FRONTEND_HOME, (0, config_1.sha256Hex)(key));
+}
+function projectWorkspaceKey(projectDir) {
+    return `project:${(0, node_path_1.resolve)(projectDir)}`;
+}
+function getWorkspaceDir(backendUrl) {
+    return getWorkspaceDirForKey((0, config_1.canonicalizeBackendUrl)(backendUrl));
+}
+function ensureWorkspace(workspaceKey) {
+    const dir = getWorkspaceDirForKey(workspaceKey);
+    if (!(0, node_fs_1.existsSync)(dir)) {
+        (0, node_fs_1.mkdirSync)(dir, { recursive: true, mode: config_1.WORKSPACE_DIR_MODE });
+    }
+    (0, node_fs_1.chmodSync)(dir, config_1.WORKSPACE_DIR_MODE);
+    return dir;
+}
+function listWorkspaces() {
+    if (!(0, node_fs_1.existsSync)(config_1.DMS_FRONTEND_HOME))
+        return [];
+    const workspaces = [];
+    for (const entry of (0, node_fs_1.readdirSync)(config_1.DMS_FRONTEND_HOME, { withFileTypes: true })) {
+        if (!entry.isDirectory())
+            continue;
+        const dir = (0, node_path_1.join)(config_1.DMS_FRONTEND_HOME, entry.name);
+        const backendUrl = readWorkspaceBackendUrl(dir);
+        if (backendUrl === undefined) {
+            console.warn(`⚠ Skipping ${dir}: no readable ${WORKSPACE_META_FILE}.`);
+            continue;
+        }
+        workspaces.push({ dir, backendUrl });
+    }
+    return workspaces;
+}
+function readWorkspaceBackendUrl(dir) {
+    let meta;
+    try {
+        meta = JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.join)(dir, WORKSPACE_META_FILE), "utf-8"));
+    }
+    catch {
+        return undefined;
+    }
+    const backendUrl = meta?.backendUrl;
+    return typeof backendUrl === "string" ? backendUrl : undefined;
+}
+function writeWorkspaceMeta(workspaceDir, backendUrl, workspaceKey) {
+    (0, node_fs_1.writeFileSync)((0, node_path_1.join)(workspaceDir, WORKSPACE_META_FILE), JSON.stringify({
+        backendUrl: (0, config_1.canonicalizeBackendUrl)(backendUrl),
+        workspaceKey,
+        updatedAt: new Date().toISOString(),
+    }, null, 2));
+}
+const BOOTSTRAP_HEADER = "x-dms-bootstrap";
+const UNAUTHORIZED_STATUSES = [401, 403];
+exports.FRONTEND_MANIFEST_VERSION = 1;
+function bootstrapHeaders(secret) {
+    return secret ? { [BOOTSTRAP_HEADER]: secret } : {};
+}
+function isUnauthorized(status) {
+    return UNAUTHORIZED_STATUSES.includes(status);
+}

package/package.json

@@ -0,0 +1,97 @@
+{
+  "name": "@antelopejs/dms-frontend",
+  "version": "0.0.1",
+  "description": "Vue 3, Vite, and Inertia frontend loader for AntelopeJS DMS",
+  "keywords": [
+    "antelope",
+    "antelopejs",
+    "dms",
+    "frontend",
+    "frontend-modules",
+    "inertia",
+    "loader",
+    "ui",
+    "vite",
+    "vue"
+  ],
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/AntelopeJS/dms-frontend.git"
+  },
+  "bin": {
+    "ajs-dms": "./dist/index.js"
+  },
+  "files": [
+    "dist/",
+    "templates/"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "provenance": true,
+    "registry": "https://registry.npmjs.org/"
+  },
+  "dependencies": {
+    "boxen": "^5.1.2",
+    "chalk": "^4.1.2",
+    "chokidar": "^4.0.3",
+    "commander": "^13.1.0",
+    "figlet": "^1.8.0",
+    "ignore": "^7.0.5",
+    "semver": "^7.7.0",
+    "unzipper": "^0.12.3"
+  },
+  "devDependencies": {
+    "@antelopejs/tooling-configs": "^0.0.4",
+    "@inertiajs/vue3": "^3.7.0",
+    "@types/figlet": "^1.7.0",
+    "@types/node": "^24.0.0",
+    "@types/semver": "^7.7.0",
+    "@types/unzipper": "^0.10.11",
+    "@unhead/vue": "^2.0.14",
+    "@vitejs/plugin-vue": "^6.0.0",
+    "@vue/server-renderer": "^3.5.0",
+    "defu": "^6.1.4",
+    "knip": "^6.34.0",
+    "ofetch": "^1.4.1",
+    "oxfmt": "^0.66.0",
+    "oxlint": "1.81.0",
+    "oxlint-tsgolint": "^7.0.2001",
+    "release-it": "^19.2.4",
+    "release-it-changelogen": "^0.1.0",
+    "rimraf": "^6.0.1",
+    "tsx": "^4.20.6",
+    "typescript": "^5.8.2",
+    "unplugin-auto-import": "^20.2.0",
+    "vite": "^7.0.0",
+    "vue": "^3.5.0",
+    "vue-i18n": "^11.1.12"
+  },
+  "peerDependencies": {
+    "@antelopejs/core": ">=1.5.0 <2"
+  },
+  "peerDependenciesMeta": {
+    "@antelopejs/core": {
+      "optional": true
+    }
+  },
+  "optionalDependencies": {
+    "@oxc-parser/binding-darwin-arm64": "^0.95.0",
+    "@oxc-parser/binding-darwin-x64": "^0.95.0",
+    "@oxc-parser/binding-linux-arm64-gnu": "^0.95.0",
+    "@oxc-parser/binding-linux-x64-gnu": "^0.95.0",
+    "@oxc-parser/binding-win32-x64-msvc": "^0.95.0"
+  },
+  "scripts": {
+    "build": "rimraf dist && tsc -p tsconfig.build.json",
+    "release": "pnpm run lint && pnpm run test && pnpm run prepack && release-it",
+    "test": "node --import tsx --test tests/*.test.ts tests/*.test.mts",
+    "test:real-source": "pnpm run build && node dist/verify-source-runner.js",
+    "format": "oxfmt .",
+    "lint": "oxlint && oxfmt --check .",
+    "typecheck": "tsc -p tsconfig.json",
+    "lint:fix": "oxlint --fix --max-warnings=1000000 && oxfmt .",
+    "knip": "knip --dependencies",
+    "knip:all": "knip"
+  }
+}