@solidxai/core 0.1.10-beta.24 → 0.1.10-beta.26

package/dist/services/module-package.service.js

@@ -0,0 +1,980 @@
+"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 __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+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 __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var ModulePackageService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModulePackageService = void 0;
+const common_1 = require("@nestjs/common");
+const crypto_1 = require("crypto");
+const archiver_1 = __importDefault(require("archiver"));
+const fs_1 = require("fs");
+const disallow_in_production_decorator_1 = require("../decorators/disallow-in-production.decorator");
+const confirm_module_package_import_dto_1 = require("../dtos/confirm-module-package-import.dto");
+const run_module_package_build_dto_1 = require("../dtos/run-module-package-build.dto");
+const run_module_package_seed_dto_1 = require("../dtos/run-module-package-seed.dto");
+const command_service_1 = require("../helpers/command.service");
+const module_metadata_helper_service_1 = require("../helpers/module-metadata-helper.service");
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const uuid_1 = require("uuid");
+var ModulePackageStatus;
+(function (ModulePackageStatus) {
+    ModulePackageStatus["uploaded"] = "uploaded";
+    ModulePackageStatus["validated"] = "validated";
+    ModulePackageStatus["awaiting_confirmation"] = "awaiting_confirmation";
+    ModulePackageStatus["import_running"] = "import_running";
+    ModulePackageStatus["awaiting_restart"] = "awaiting_restart";
+    ModulePackageStatus["build_running"] = "build_running";
+    ModulePackageStatus["build_failed"] = "build_failed";
+    ModulePackageStatus["build_succeeded"] = "build_succeeded";
+    ModulePackageStatus["seed_running"] = "seed_running";
+    ModulePackageStatus["seed_failed"] = "seed_failed";
+    ModulePackageStatus["completed"] = "completed";
+    ModulePackageStatus["failed"] = "failed";
+})(ModulePackageStatus || (ModulePackageStatus = {}));
+let ModulePackageService = ModulePackageService_1 = class ModulePackageService {
+    constructor(commandService, moduleMetadataHelperService) {
+        this.commandService = commandService;
+        this.moduleMetadataHelperService = moduleMetadataHelperService;
+        this.logger = new common_1.Logger(ModulePackageService_1.name);
+    }
+    async validateUpload(file) {
+        if (!file) {
+            throw new common_1.BadRequestException('A .sldx archive file is required.');
+        }
+        await this.cleanupModulePackageTransactions();
+        const transactionKey = (0, uuid_1.v4)();
+        const workingDir = await this.createWorkingDir(transactionKey);
+        const archiveFileName = file.originalname || path.basename(file.path);
+        const archiveFilePath = path.join(workingDir, archiveFileName);
+        const extractDirPath = path.join(workingDir, 'extract');
+        await fs.mkdir(extractDirPath, { recursive: true });
+        await fs.rename(file.path, archiveFilePath);
+        const parsed = await this.parseArchive(archiveFilePath);
+        await this.extractArchive(archiveFilePath, extractDirPath);
+        const transaction = {
+            transactionKey,
+            status: parsed.validation.valid ? ModulePackageStatus.awaiting_confirmation : ModulePackageStatus.failed,
+            currentStep: 'preview',
+            moduleName: parsed.manifest.module.name,
+            moduleDisplayName: parsed.manifest.module.displayName ?? null,
+            archiveFileName,
+            archiveFilePath,
+            extractDirPath,
+            archiveRootPrefix: parsed.archiveRootPrefix,
+            manifest: parsed.manifest,
+            metadataDocument: parsed.metadataDocument,
+            preview: parsed.preview,
+            validation: parsed.validation,
+            conflicts: parsed.preview.conflicts,
+            outputs: {
+                import: null,
+                build: null,
+                seed: null,
+            },
+            errorMessage: parsed.validation.valid ? null : parsed.validation.errors.join('\n'),
+            createdAt: new Date().toISOString(),
+            updatedAt: new Date().toISOString(),
+        };
+        await this.writeStatusFile(transactionKey, transaction);
+        return this.toStatusResponse(transaction);
+    }
+    async getStatus(transactionKey) {
+        const transaction = await this.loadTransaction(transactionKey);
+        return this.toStatusResponse(transaction);
+    }
+    async getLatestResumableImport() {
+        await this.cleanupModulePackageTransactions();
+        const transaction = await this.resolveLatestResumableTransaction();
+        return transaction ? this.toStatusResponse(transaction) : null;
+    }
+    async dismissImport(transactionKey) {
+        const transaction = await this.loadTransaction(transactionKey);
+        await this.clearActiveTransactionIfMatches(transaction.transactionKey);
+        return this.toStatusResponse(transaction);
+    }
+    async clearPackageRuntime() {
+        const runtimeRoot = this.getModulePackageRuntimeRoot();
+        const importsRoot = this.getModulePackageImportsRoot();
+        const exportsRoot = this.getModulePackageExportsRoot();
+        const snapshot = await this.collectRuntimeCleanupSnapshot();
+        await fs.rm(runtimeRoot, { recursive: true, force: true });
+        await fs.mkdir(importsRoot, { recursive: true });
+        await fs.mkdir(exportsRoot, { recursive: true });
+        return {
+            runtimeRoot,
+            ...snapshot,
+            clearedAt: new Date().toISOString(),
+        };
+    }
+    async exportModulePackage(moduleNameInput) {
+        const moduleName = (moduleNameInput ?? '').trim();
+        if (!moduleName) {
+            throw new common_1.BadRequestException('A module name is required to export a module package.');
+        }
+        const solidApiModulePath = this.getSolidApiModuleTargetPath(moduleName);
+        const solidUiModulePath = this.getSolidUiModuleTargetPath(moduleName);
+        const metadataFilePath = await this.moduleMetadataHelperService.getModuleMetadataFilePath(moduleName);
+        await this.assertPathExists(solidApiModulePath, 'solid-api module path');
+        await this.assertPathExists(solidUiModulePath, 'solid-ui module path');
+        await this.assertPathExists(metadataFilePath, 'module metadata file');
+        const metadataDocument = this.parseMetadataDocument(await fs.readFile(metadataFilePath, 'utf-8'), []);
+        const transactionKey = (0, uuid_1.v4)();
+        const exportRoot = path.join(this.getModulePackageExportsRoot(), transactionKey);
+        const stagingDir = path.join(exportRoot, 'staging');
+        const archiveFileName = `${moduleName}.sldx`;
+        const archiveFilePath = path.join(exportRoot, archiveFileName);
+        await fs.mkdir(path.join(stagingDir, 'solid-api', 'src'), { recursive: true });
+        await fs.mkdir(path.join(stagingDir, 'solid-ui', 'src'), { recursive: true });
+        await fs.cp(solidApiModulePath, path.join(stagingDir, 'solid-api', 'src', moduleName), { recursive: true });
+        await fs.cp(solidUiModulePath, path.join(stagingDir, 'solid-ui', 'src', moduleName), { recursive: true });
+        const manifest = await this.buildExportManifest(moduleName, metadataDocument, stagingDir);
+        await fs.writeFile(path.join(stagingDir, 'manifest.json'), JSON.stringify(manifest, null, 2), 'utf-8');
+        await this.createArchiveFromDirectory(stagingDir, archiveFilePath);
+        return {
+            fileName: archiveFileName,
+            filePath: archiveFilePath,
+            mimeType: 'application/zip',
+        };
+    }
+    async confirmImport(transactionKey, dto = {}) {
+        const transaction = await this.loadTransaction(transactionKey);
+        const preview = transaction.preview;
+        const validation = transaction.validation;
+        if (!preview || !validation) {
+            throw new common_1.BadRequestException('The module package transaction is missing preview or validation data.');
+        }
+        if (!validation.valid) {
+            throw new common_1.BadRequestException({
+                message: 'The uploaded module package is invalid and cannot be imported.',
+                validation,
+            });
+        }
+        const overwriteExisting = dto.overwriteExisting ?? false;
+        if (preview.conflicts.length > 0 && !overwriteExisting) {
+            throw new common_1.BadRequestException({
+                message: 'Conflicts were detected. Re-submit with overwriteExisting=true to continue.',
+                conflicts: preview.conflicts,
+            });
+        }
+        transaction.status = ModulePackageStatus.import_running;
+        transaction.currentStep = 'import';
+        transaction.errorMessage = null;
+        await this.writeStatusFile(transactionKey, transaction);
+        try {
+            const moduleName = preview.module.name;
+            const solidApiTarget = this.getSolidApiModuleTargetPath(moduleName);
+            const solidUiTarget = this.getSolidUiModuleTargetPath(moduleName);
+            const extractRoot = transaction.archiveRootPrefix
+                ? path.join(transaction.extractDirPath, transaction.archiveRootPrefix.replace(/\/$/, ''))
+                : transaction.extractDirPath;
+            const solidApiSource = path.join(extractRoot, 'solid-api', 'src', moduleName);
+            const solidUiSource = path.join(extractRoot, 'solid-ui', 'src', moduleName);
+            await this.assertPathExists(solidApiSource, 'solid-api module source');
+            await this.assertPathExists(solidUiSource, 'solid-ui module source');
+            if (overwriteExisting) {
+                await fs.rm(solidApiTarget, { recursive: true, force: true });
+                await fs.rm(solidUiTarget, { recursive: true, force: true });
+            }
+            await fs.mkdir(path.dirname(solidApiTarget), { recursive: true });
+            await fs.mkdir(path.dirname(solidUiTarget), { recursive: true });
+            await fs.cp(solidApiSource, solidApiTarget, { recursive: true, force: overwriteExisting });
+            await fs.cp(solidUiSource, solidUiTarget, { recursive: true, force: overwriteExisting });
+            if (transaction.extractDirPath) {
+                await fs.rm(transaction.extractDirPath, { recursive: true, force: true });
+                transaction.extractDirPath = null;
+            }
+            transaction.status = ModulePackageStatus.awaiting_restart;
+            transaction.currentStep = 'restart';
+            transaction.outputs.import = [
+                `Placed solid-api module at ${solidApiTarget}`,
+                `Placed solid-ui module at ${solidUiTarget}`,
+                `Metadata file placed at ${preview.requiredPaths.metadataPath}`,
+            ].join('\n');
+            await this.writeStatusFile(transactionKey, transaction);
+            await this.syncActiveTransactionPointer(transaction);
+            return this.toStatusResponse(transaction);
+        }
+        catch (error) {
+            transaction.status = ModulePackageStatus.failed;
+            transaction.currentStep = 'import';
+            transaction.errorMessage = error.message ?? 'Failed to import the module package.';
+            await this.writeStatusFile(transactionKey, transaction);
+            await this.syncActiveTransactionPointer(transaction);
+            throw error;
+        }
+    }
+    async runBuild(transactionKey, dto = {}) {
+        const transaction = await this.loadTransaction(transactionKey);
+        transaction.status = ModulePackageStatus.build_running;
+        transaction.currentStep = 'build';
+        transaction.errorMessage = null;
+        await this.writeStatusFile(transactionKey, transaction);
+        try {
+            const buildSolidApi = dto.buildSolidApi ?? true;
+            const buildSolidUi = dto.buildSolidUi ?? true;
+            const outputs = [];
+            const failedTargets = [];
+            const projectRoot = this.getProjectRoot();
+            if (buildSolidApi) {
+                try {
+                    const output = await this.commandService.executeCommandWithArgs({
+                        command: 'npx',
+                        args: ['-y', '@solidxai/solidctl@latest', 'build'],
+                        cwd: projectRoot,
+                    });
+                    outputs.push(`solidctl build [success]\n${output}`.trim());
+                }
+                catch (error) {
+                    failedTargets.push('solidctl build');
+                    outputs.push(`solidctl build [failed]\n${error?.message ?? 'Build failed.'}`.trim());
+                }
+            }
+            if (buildSolidUi) {
+                try {
+                    const output = await this.commandService.executeCommandWithArgs({
+                        command: 'npx',
+                        args: ['-y', '@solidxai/solidctl@latest', 'build', '--ui-only'],
+                        cwd: projectRoot,
+                    });
+                    outputs.push(`solidctl build --ui-only [success]\n${output}`.trim());
+                }
+                catch (error) {
+                    failedTargets.push('solidctl build --ui-only');
+                    outputs.push(`solidctl build --ui-only [failed]\n${error?.message ?? 'Build failed.'}`.trim());
+                }
+            }
+            transaction.status = failedTargets.length > 0
+                ? ModulePackageStatus.build_failed
+                : ModulePackageStatus.build_succeeded;
+            transaction.currentStep = 'build';
+            transaction.outputs.build = outputs.join('\n\n');
+            transaction.errorMessage = failedTargets.length > 0
+                ? `Build completed with errors in: ${failedTargets.join(', ')}`
+                : null;
+            await this.writeStatusFile(transactionKey, transaction);
+            await this.syncActiveTransactionPointer(transaction);
+            return this.toStatusResponse(transaction);
+        }
+        catch (error) {
+            transaction.status = ModulePackageStatus.build_failed;
+            transaction.currentStep = 'build';
+            transaction.errorMessage = error.message ?? 'Build failed.';
+            transaction.outputs.build = error.message ?? '';
+            await this.writeStatusFile(transactionKey, transaction);
+            await this.syncActiveTransactionPointer(transaction);
+            throw error;
+        }
+    }
+    async runSeed(transactionKey, dto = {}) {
+        const transaction = await this.loadTransaction(transactionKey);
+        const moduleName = transaction.moduleName;
+        if (!moduleName) {
+            throw new common_1.BadRequestException('Unable to seed because the transaction is missing moduleName.');
+        }
+        transaction.status = ModulePackageStatus.seed_running;
+        transaction.currentStep = 'seed';
+        transaction.errorMessage = null;
+        await this.writeStatusFile(transactionKey, transaction);
+        try {
+            const output = await this.commandService.executeCommandWithArgs({
+                command: 'npx',
+                args: ['-y', '@solidxai/solidctl@latest', 'seed', '--modules-to-seed', moduleName],
+                cwd: this.getProjectRoot(),
+            });
+            transaction.status = ModulePackageStatus.completed;
+            transaction.currentStep = 'done';
+            transaction.outputs.seed = [
+                `solidctl seed --modules-to-seed ${moduleName} [success]`,
+                output,
+            ].filter(Boolean).join('\n');
+            await this.writeStatusFile(transactionKey, transaction);
+            await this.syncActiveTransactionPointer(transaction);
+            return this.toStatusResponse(transaction);
+        }
+        catch (error) {
+            transaction.status = ModulePackageStatus.seed_failed;
+            transaction.currentStep = 'seed';
+            transaction.errorMessage = error.message ?? 'Seed failed.';
+            transaction.outputs.seed = error.message ?? '';
+            await this.writeStatusFile(transactionKey, transaction);
+            await this.syncActiveTransactionPointer(transaction);
+            return this.toStatusResponse(transaction);
+        }
+    }
+    async parseArchive(archiveFilePath) {
+        const entries = await this.listArchiveEntries(archiveFilePath);
+        const archiveRootPrefix = this.detectArchiveRootPrefix(entries);
+        const normalizedEntries = this.normalizeArchiveEntries(entries, archiveRootPrefix);
+        const validationErrors = [];
+        const validationWarnings = [];
+        if (path.extname(archiveFilePath).toLowerCase() !== '.sldx') {
+            validationErrors.push('Only .sldx archives are supported.');
+        }
+        const unsafeEntries = normalizedEntries.filter((entry) => this.isUnsafeArchivePath(entry));
+        if (unsafeEntries.length > 0) {
+            validationErrors.push(`Archive contains unsafe paths: ${unsafeEntries.join(', ')}`);
+        }
+        if (!normalizedEntries.includes('manifest.json')) {
+            validationErrors.push('Archive is missing manifest.json at the root.');
+        }
+        const manifestArchivePath = this.toArchiveEntryPath(archiveRootPrefix, 'manifest.json');
+        const manifestText = normalizedEntries.includes('manifest.json')
+            ? await this.readArchiveEntry(archiveFilePath, manifestArchivePath)
+            : '';
+        const manifest = this.parseManifest(manifestText, validationErrors);
+        if (!manifest) {
+            return {
+                entries: normalizedEntries,
+                archiveRootPrefix,
+                manifest: this.getFallbackManifest(),
+                metadataDocument: null,
+                validation: {
+                    valid: false,
+                    errors: validationErrors,
+                    warnings: validationWarnings,
+                },
+                preview: {
+                    module: { name: '', displayName: '' },
+                    manifest: this.getFallbackManifest(),
+                    contentsSummary: {
+                        totalEntries: normalizedEntries.length,
+                        solidApiEntries: normalizedEntries.filter((entry) => entry.startsWith('solid-api/')).length,
+                        solidUiEntries: normalizedEntries.filter((entry) => entry.startsWith('solid-ui/')).length,
+                    },
+                    requiredPaths: {
+                        metadataPath: '',
+                        apiModulePath: '',
+                        uiModulePath: '',
+                    },
+                    conflicts: [],
+                    fileTree: normalizedEntries,
+                    nextActions: ['Fix archive structure and upload again.'],
+                },
+            };
+        }
+        if (manifest.packageType !== ModulePackageService_1.SUPPORTED_PACKAGE_TYPE) {
+            validationErrors.push(`manifest.json packageType must be "${ModulePackageService_1.SUPPORTED_PACKAGE_TYPE}".`);
+        }
+        if (manifest.schemaVersion !== ModulePackageService_1.SUPPORTED_SCHEMA_VERSION) {
+            validationErrors.push(`manifest.json schemaVersion must be "${ModulePackageService_1.SUPPORTED_SCHEMA_VERSION}".`);
+        }
+        if (!manifest.module?.name) {
+            validationErrors.push('manifest.json module.name is required.');
+        }
+        const moduleName = manifest.module?.name ?? '';
+        const expectedPaths = this.buildExpectedPaths(moduleName);
+        if (manifest.contents?.metadataPath !== expectedPaths.metadataPath) {
+            validationErrors.push(`manifest.json contents.metadataPath must be "${expectedPaths.metadataPath}".`);
+        }
+        if (manifest.contents?.apiModulePath !== expectedPaths.apiModulePath) {
+            validationErrors.push(`manifest.json contents.apiModulePath must be "${expectedPaths.apiModulePath}".`);
+        }
+        if (manifest.contents?.uiModulePath !== expectedPaths.uiModulePath) {
+            validationErrors.push(`manifest.json contents.uiModulePath must be "${expectedPaths.uiModulePath}".`);
+        }
+        if (!normalizedEntries.includes(expectedPaths.metadataPath)) {
+            validationErrors.push(`Archive is missing ${expectedPaths.metadataPath}.`);
+        }
+        if (!normalizedEntries.includes(expectedPaths.apiModulePath)) {
+            validationErrors.push(`Archive is missing ${expectedPaths.apiModulePath}.`);
+        }
+        if (!normalizedEntries.includes(expectedPaths.uiModulePath)) {
+            validationErrors.push(`Archive is missing ${expectedPaths.uiModulePath}.`);
+        }
+        const metadataDocument = normalizedEntries.includes(expectedPaths.metadataPath)
+            ? this.parseMetadataDocument(await this.readArchiveEntry(archiveFilePath, this.toArchiveEntryPath(archiveRootPrefix, expectedPaths.metadataPath)), validationErrors)
+            : null;
+        const metadataModuleName = metadataDocument?.moduleMetadata?.name;
+        if (metadataModuleName && metadataModuleName !== moduleName) {
+            validationErrors.push(`Metadata module name "${metadataModuleName}" does not match manifest module name "${moduleName}".`);
+        }
+        if (!manifest.checksums || Object.keys(manifest.checksums).length === 0) {
+            validationWarnings.push('manifest.json does not include checksums. Checksums are recommended.');
+        }
+        const conflicts = await this.detectConflicts(moduleName);
+        if (conflicts.length > 0) {
+            validationWarnings.push('The target module already exists locally and will require overwrite confirmation.');
+        }
+        const validation = {
+            valid: validationErrors.length === 0,
+            errors: validationErrors,
+            warnings: validationWarnings,
+        };
+        const preview = {
+            module: manifest.module,
+            manifest,
+            contentsSummary: {
+                totalEntries: normalizedEntries.length,
+                solidApiEntries: normalizedEntries.filter((entry) => entry.startsWith('solid-api/')).length,
+                solidUiEntries: normalizedEntries.filter((entry) => entry.startsWith('solid-ui/')).length,
+            },
+            requiredPaths: expectedPaths,
+            conflicts,
+            fileTree: normalizedEntries,
+            nextActions: [
+                'Review archive preview.',
+                'Confirm import to place files locally.',
+                'Wait for service restart, then run build and seed.',
+            ],
+        };
+        return {
+            entries: normalizedEntries,
+            archiveRootPrefix,
+            manifest,
+            metadataDocument,
+            validation,
+            preview,
+        };
+    }
+    parseManifest(manifestText, validationErrors) {
+        if (!manifestText) {
+            return null;
+        }
+        try {
+            return JSON.parse(manifestText);
+        }
+        catch (error) {
+            validationErrors.push('manifest.json is not valid JSON.');
+            return null;
+        }
+    }
+    parseMetadataDocument(documentText, validationErrors) {
+        try {
+            return JSON.parse(documentText);
+        }
+        catch (error) {
+            validationErrors.push('Module metadata JSON is not valid JSON.');
+            return null;
+        }
+    }
+    async listArchiveEntries(archiveFilePath) {
+        const output = await this.commandService.executeCommandWithArgs({
+            command: 'unzip',
+            args: ['-Z1', archiveFilePath],
+        });
+        return output
+            .split(/\r?\n/)
+            .map((entry) => entry.trim())
+            .filter(Boolean);
+    }
+    async readArchiveEntry(archiveFilePath, entryPath) {
+        return this.commandService.executeCommandWithArgs({
+            command: 'unzip',
+            args: ['-p', archiveFilePath, entryPath],
+        });
+    }
+    async extractArchive(archiveFilePath, extractDirPath) {
+        await this.commandService.executeCommandWithArgs({
+            command: 'unzip',
+            args: ['-o', archiveFilePath, '-d', extractDirPath],
+        });
+    }
+    async detectConflicts(moduleName) {
+        const conflicts = [];
+        const solidApiTarget = this.getSolidApiModuleTargetPath(moduleName);
+        const solidUiTarget = this.getSolidUiModuleTargetPath(moduleName);
+        const metadataFilePath = await this.moduleMetadataHelperService.getModuleMetadataFilePath(moduleName);
+        if (await this.pathExists(solidApiTarget)) {
+            conflicts.push(`solid-api module already exists at ${solidApiTarget}`);
+        }
+        if (await this.pathExists(solidUiTarget)) {
+            conflicts.push(`solid-ui module already exists at ${solidUiTarget}`);
+        }
+        if (await this.pathExists(metadataFilePath)) {
+            conflicts.push(`module metadata already exists at ${metadataFilePath}`);
+        }
+        return conflicts;
+    }
+    buildExpectedPaths(moduleName) {
+        return {
+            metadataPath: `solid-api/src/${moduleName}/metadata/${moduleName}-metadata.json`,
+            apiModulePath: `solid-api/src/${moduleName}/${moduleName}.module.ts`,
+            uiModulePath: `solid-ui/src/${moduleName}/${moduleName}.ui-module.ts`,
+        };
+    }
+    detectArchiveRootPrefix(entries) {
+        const normalized = entries
+            .map((entry) => entry.trim())
+            .filter(Boolean)
+            .filter((entry) => !this.isMacOsMetadataEntry(entry));
+        if (normalized.length === 0) {
+            return null;
+        }
+        const topLevelSegments = normalized
+            .map((entry) => entry.split('/')[0])
+            .filter(Boolean);
+        const uniqueTopLevelSegments = Array.from(new Set(topLevelSegments));
+        if (uniqueTopLevelSegments.length !== 1) {
+            return null;
+        }
+        const onlySegment = uniqueTopLevelSegments[0];
+        const hasNestedEntries = normalized.some((entry) => entry.startsWith(`${onlySegment}/`));
+        return hasNestedEntries ? `${onlySegment}/` : null;
+    }
+    normalizeArchiveEntries(entries, archiveRootPrefix) {
+        const filteredEntries = entries.filter((entry) => !this.isMacOsMetadataEntry(entry));
+        if (!archiveRootPrefix) {
+            return filteredEntries;
+        }
+        return filteredEntries
+            .map((entry) => entry.startsWith(archiveRootPrefix) ? entry.slice(archiveRootPrefix.length) : entry)
+            .filter(Boolean);
+    }
+    toArchiveEntryPath(archiveRootPrefix, normalizedEntryPath) {
+        return archiveRootPrefix ? `${archiveRootPrefix}${normalizedEntryPath}` : normalizedEntryPath;
+    }
+    isUnsafeArchivePath(entry) {
+        return entry.startsWith('/') || entry.includes('..') || /^[A-Za-z]:/.test(entry);
+    }
+    isMacOsMetadataEntry(entry) {
+        const normalizedEntry = entry.trim();
+        if (!normalizedEntry) {
+            return false;
+        }
+        const segments = normalizedEntry.split('/').filter(Boolean);
+        return segments.some((segment) => segment === '__MACOSX' || segment.startsWith('._'));
+    }
+    getFallbackManifest() {
+        return {
+            schemaVersion: ModulePackageService_1.SUPPORTED_SCHEMA_VERSION,
+            packageType: ModulePackageService_1.SUPPORTED_PACKAGE_TYPE,
+            module: { name: '', displayName: '' },
+            contents: {
+                metadataPath: '',
+                apiModulePath: '',
+                uiModulePath: '',
+            },
+        };
+    }
+    async loadTransaction(transactionKey) {
+        this.assertSafeTransactionKey(transactionKey);
+        const statusFilePath = this.getStatusFilePath(transactionKey);
+        if (!(await this.pathExists(statusFilePath))) {
+            throw new common_1.NotFoundException(`Module package transaction ${transactionKey} was not found.`);
+        }
+        return JSON.parse(await fs.readFile(statusFilePath, 'utf-8'));
+    }
+    isResumableStatus(status) {
+        return [
+            ModulePackageStatus.import_running,
+            ModulePackageStatus.awaiting_restart,
+            ModulePackageStatus.build_running,
+            ModulePackageStatus.build_failed,
+            ModulePackageStatus.build_succeeded,
+            ModulePackageStatus.seed_running,
+            ModulePackageStatus.seed_failed,
+        ].includes(status);
+    }
+    async createWorkingDir(transactionKey) {
+        const baseDir = path.join(this.getModulePackageImportsRoot(), transactionKey);
+        await fs.mkdir(baseDir, { recursive: true });
+        return baseDir;
+    }
+    getSolidApiRoot() {
+        return process.cwd();
+    }
+    getProjectRoot() {
+        return path.resolve(this.getSolidApiRoot(), '..');
+    }
+    getSolidUiRoot() {
+        return path.join(this.getProjectRoot(), 'solid-ui');
+    }
+    getModulePackageImportsRoot() {
+        return path.join(this.getModulePackageRuntimeRoot(), 'module-package-imports');
+    }
+    getModulePackageExportsRoot() {
+        return path.join(this.getModulePackageRuntimeRoot(), 'module-package-exports');
+    }
+    getModulePackageRuntimeRoot() {
+        const configuredRuntimeRoot = process.env.SOLIDX_MODULE_PACKAGE_RUNTIME_DIR?.trim();
+        if (configuredRuntimeRoot) {
+            return path.resolve(configuredRuntimeRoot);
+        }
+        return path.join(this.getProjectRoot(), '.solidx-runtime');
+    }
+    getSolidApiModuleTargetPath(moduleName) {
+        return path.join(this.getSolidApiRoot(), 'src', moduleName);
+    }
+    getSolidUiModuleTargetPath(moduleName) {
+        return path.join(this.getSolidUiRoot(), 'src', moduleName);
+    }
+    async pathExists(targetPath) {
+        try {
+            await fs.access(targetPath);
+            return true;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    async assertPathExists(targetPath, label) {
+        if (!(await this.pathExists(targetPath))) {
+            throw new common_1.BadRequestException(`Expected ${label} at ${targetPath}, but it was not found in the extracted archive.`);
+        }
+    }
+    async readDirSafe(targetPath) {
+        try {
+            return await fs.readdir(targetPath, { withFileTypes: true });
+        }
+        catch (error) {
+            return [];
+        }
+    }
+    assertSafeTransactionKey(transactionKey) {
+        if (!/^[a-zA-Z0-9-]+$/.test(transactionKey)) {
+            throw new common_1.BadRequestException('Invalid module package transaction key.');
+        }
+    }
+    getStatusFilePath(transactionKey) {
+        this.assertSafeTransactionKey(transactionKey);
+        return path.join(this.getModulePackageImportsRoot(), transactionKey, 'status.json');
+    }
+    getActiveTransactionFilePath() {
+        return path.join(this.getModulePackageImportsRoot(), 'active-transaction.json');
+    }
+    async writeStatusFile(transactionKey, payload) {
+        payload.updatedAt = new Date().toISOString();
+        const statusFilePath = this.getStatusFilePath(transactionKey);
+        await fs.mkdir(path.dirname(statusFilePath), { recursive: true });
+        await fs.writeFile(statusFilePath, JSON.stringify(payload, null, 2));
+    }
+    async markActiveTransaction(transactionKey) {
+        const activeTransactionFilePath = this.getActiveTransactionFilePath();
+        await fs.mkdir(path.dirname(activeTransactionFilePath), { recursive: true });
+        const payload = {
+            transactionKey,
+            updatedAt: new Date().toISOString(),
+        };
+        await fs.writeFile(activeTransactionFilePath, JSON.stringify(payload, null, 2));
+    }
+    async clearActiveTransactionIfMatches(transactionKey) {
+        const activeTransaction = await this.loadActiveTransactionPointer();
+        if (!activeTransaction || activeTransaction.transactionKey !== transactionKey) {
+            return;
+        }
+        await fs.rm(this.getActiveTransactionFilePath(), { force: true });
+    }
+    async loadActiveTransactionPointer() {
+        try {
+            return JSON.parse(await fs.readFile(this.getActiveTransactionFilePath(), 'utf-8'));
+        }
+        catch (error) {
+            return null;
+        }
+    }
+    async syncActiveTransactionPointer(transaction) {
+        if (this.isResumableStatus(transaction.status)) {
+            await this.markActiveTransaction(transaction.transactionKey);
+            return;
+        }
+        await this.clearActiveTransactionIfMatches(transaction.transactionKey);
+    }
+    async collectRuntimeCleanupSnapshot() {
+        const importEntries = await this.readDirSafe(this.getModulePackageImportsRoot());
+        const exportEntries = await this.readDirSafe(this.getModulePackageExportsRoot());
+        const importTransactionEntries = importEntries.filter((entry) => entry.isDirectory() && /^[a-zA-Z0-9-]+$/.test(entry.name));
+        const exportTransactionEntries = exportEntries.filter((entry) => entry.isDirectory() && /^[a-zA-Z0-9-]+$/.test(entry.name));
+        const importLooseEntries = importEntries.filter((entry) => !(entry.isDirectory() && /^[a-zA-Z0-9-]+$/.test(entry.name)));
+        const exportLooseEntries = exportEntries.filter((entry) => !(entry.isDirectory() && /^[a-zA-Z0-9-]+$/.test(entry.name)));
+        return {
+            removedImportTransactions: importTransactionEntries.length,
+            removedExportTransactions: exportTransactionEntries.length,
+            removedImportLooseEntries: importLooseEntries.length,
+            removedExportLooseEntries: exportLooseEntries.length,
+            clearedActiveTransactionPointer: importEntries.some((entry) => entry.name === 'active-transaction.json'),
+        };
+    }
+    getCompletedTransactionRetentionMs() {
+        const retentionDays = Number(process.env.SOLIDX_MODULE_PACKAGE_RETENTION_DAYS ?? 7);
+        const safeDays = Number.isFinite(retentionDays) && retentionDays > 0 ? retentionDays : 7;
+        return safeDays * 24 * 60 * 60 * 1000;
+    }
+    getPendingTransactionRetentionMs() {
+        const retentionHours = Number(process.env.SOLIDX_MODULE_PACKAGE_PENDING_RETENTION_HOURS ?? 24);
+        const safeHours = Number.isFinite(retentionHours) && retentionHours > 0 ? retentionHours : 24;
+        return safeHours * 60 * 60 * 1000;
+    }
+    async cleanupModulePackageTransactions() {
+        const importsRoot = this.getModulePackageImportsRoot();
+        const activePointer = await this.loadActiveTransactionPointer();
+        const now = Date.now();
+        try {
+            await fs.mkdir(importsRoot, { recursive: true });
+            const entries = await fs.readdir(importsRoot, { withFileTypes: true });
+            for (const entry of entries) {
+                if (!entry.isDirectory()) {
+                    continue;
+                }
+                const transactionKey = entry.name;
+                if (!/^[a-zA-Z0-9-]+$/.test(transactionKey)) {
+                    continue;
+                }
+                const statusFilePath = this.getStatusFilePath(transactionKey);
+                let transaction = null;
+                try {
+                    transaction = JSON.parse(await fs.readFile(statusFilePath, 'utf-8'));
+                }
+                catch (error) {
+                    continue;
+                }
+                const updatedAtMs = transaction.updatedAt ? new Date(transaction.updatedAt).getTime() : 0;
+                const ageMs = updatedAtMs > 0 ? now - updatedAtMs : Number.MAX_SAFE_INTEGER;
+                const isResumable = this.isResumableStatus(transaction.status);
+                const maxAgeMs = isResumable
+                    ? this.getPendingTransactionRetentionMs()
+                    : this.getCompletedTransactionRetentionMs();
+                const shouldDelete = ageMs > maxAgeMs;
+                if (!shouldDelete) {
+                    continue;
+                }
+                await fs.rm(path.join(importsRoot, transactionKey), { recursive: true, force: true });
+                if (activePointer?.transactionKey === transactionKey) {
+                    await fs.rm(this.getActiveTransactionFilePath(), { force: true });
+                }
+            }
+        }
+        catch (error) {
+            this.logger.warn(`Failed to clean up module package transactions: ${String(error)}`);
+        }
+    }
+    async resolveLatestResumableTransaction() {
+        const activePointer = await this.loadActiveTransactionPointer();
+        if (activePointer?.transactionKey) {
+            try {
+                const activeTransaction = await this.loadTransaction(activePointer.transactionKey);
+                if (this.isResumableStatus(activeTransaction.status)) {
+                    return activeTransaction;
+                }
+                await this.clearActiveTransactionIfMatches(activePointer.transactionKey);
+            }
+            catch (error) {
+                await this.clearActiveTransactionIfMatches(activePointer.transactionKey);
+            }
+        }
+        const importsRoot = this.getModulePackageImportsRoot();
+        const candidates = [];
+        try {
+            const entries = await fs.readdir(importsRoot, { withFileTypes: true });
+            for (const entry of entries) {
+                if (!entry.isDirectory()) {
+                    continue;
+                }
+                const transactionKey = entry.name;
+                if (!/^[a-zA-Z0-9-]+$/.test(transactionKey)) {
+                    continue;
+                }
+                try {
+                    const transaction = await this.loadTransaction(transactionKey);
+                    if (this.isResumableStatus(transaction.status)) {
+                        candidates.push(transaction);
+                    }
+                }
+                catch (error) {
+                    continue;
+                }
+            }
+        }
+        catch (error) {
+            return null;
+        }
+        candidates.sort((left, right) => {
+            const leftUpdatedAt = new Date(left.updatedAt ?? left.createdAt ?? 0).getTime();
+            const rightUpdatedAt = new Date(right.updatedAt ?? right.createdAt ?? 0).getTime();
+            return rightUpdatedAt - leftUpdatedAt;
+        });
+        const latest = candidates[0] ?? null;
+        if (latest) {
+            await this.markActiveTransaction(latest.transactionKey);
+        }
+        return latest;
+    }
+    toStatusResponse(transaction) {
+        return {
+            transactionKey: transaction.transactionKey,
+            status: transaction.status,
+            currentStep: transaction.currentStep,
+            moduleName: transaction.moduleName,
+            moduleDisplayName: transaction.moduleDisplayName,
+            archiveFileName: transaction.archiveFileName,
+            manifest: transaction.manifest,
+            preview: transaction.preview,
+            validation: transaction.validation,
+            conflicts: transaction.conflicts,
+            outputs: transaction.outputs,
+            errorMessage: transaction.errorMessage,
+            createdAt: transaction.createdAt,
+            updatedAt: transaction.updatedAt,
+        };
+    }
+    async buildExportManifest(moduleName, metadataDocument, stagingDir) {
+        const expectedPaths = this.buildExpectedPaths(moduleName);
+        const checksums = await this.computeDirectoryChecksums(stagingDir, ['manifest.json']);
+        return {
+            schemaVersion: ModulePackageService_1.SUPPORTED_SCHEMA_VERSION,
+            packageType: ModulePackageService_1.SUPPORTED_PACKAGE_TYPE,
+            exportedAt: new Date().toISOString(),
+            generatedBy: {
+                name: '@solidxai/core',
+            },
+            module: {
+                name: moduleName,
+                displayName: metadataDocument?.moduleMetadata?.displayName,
+                description: metadataDocument?.moduleMetadata?.description,
+            },
+            contents: expectedPaths,
+            postImport: {
+                recommendedSteps: ['restart', 'build', 'seed'],
+            },
+            checksums,
+        };
+    }
+    async computeDirectoryChecksums(rootDir, excludedRelativePaths = []) {
+        const excludedPaths = new Set(excludedRelativePaths.map((entry) => entry.replace(/\\/g, '/')));
+        const filePaths = await this.collectFilePathsRecursively(rootDir);
+        const checksums = {};
+        for (const filePath of filePaths) {
+            const relativePath = path.relative(rootDir, filePath).replace(/\\/g, '/');
+            if (excludedPaths.has(relativePath)) {
+                continue;
+            }
+            checksums[relativePath] = await this.computeSha256(filePath);
+        }
+        return checksums;
+    }
+    async collectFilePathsRecursively(rootDir) {
+        const entries = await fs.readdir(rootDir, { withFileTypes: true });
+        const nestedPaths = await Promise.all(entries.map(async (entry) => {
+            const entryPath = path.join(rootDir, entry.name);
+            if (entry.isDirectory()) {
+                return this.collectFilePathsRecursively(entryPath);
+            }
+            return [entryPath];
+        }));
+        return nestedPaths.flat();
+    }
+    async createArchiveFromDirectory(sourceDir, archiveFilePath) {
+        await fs.mkdir(path.dirname(archiveFilePath), { recursive: true });
+        await new Promise((resolve, reject) => {
+            const output = (0, fs_1.createWriteStream)(archiveFilePath);
+            const archive = (0, archiver_1.default)('zip', {
+                zlib: { level: 9 },
+            });
+            const rejectOnce = (error) => {
+                output.destroy();
+                reject(error);
+            };
+            output.on('close', () => resolve());
+            output.on('error', rejectOnce);
+            archive.on('warning', rejectOnce);
+            archive.on('error', rejectOnce);
+            archive.pipe(output);
+            archive.directory(sourceDir, false);
+            void archive.finalize();
+        });
+    }
+    async computeSha256(filePath) {
+        const fileBuffer = await fs.readFile(filePath);
+        return (0, crypto_1.createHash)('sha256').update(fileBuffer).digest('hex');
+    }
+};
+exports.ModulePackageService = ModulePackageService;
+ModulePackageService.SUPPORTED_SCHEMA_VERSION = '1.0';
+ModulePackageService.SUPPORTED_PACKAGE_TYPE = 'solidx-module';
+__decorate([
+    (0, disallow_in_production_decorator_1.DisallowInProduction)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], ModulePackageService.prototype, "validateUpload", null);
+__decorate([
+    (0, disallow_in_production_decorator_1.DisallowInProduction)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], ModulePackageService.prototype, "getLatestResumableImport", null);
+__decorate([
+    (0, disallow_in_production_decorator_1.DisallowInProduction)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], ModulePackageService.prototype, "dismissImport", null);
+__decorate([
+    (0, disallow_in_production_decorator_1.DisallowInProduction)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], ModulePackageService.prototype, "clearPackageRuntime", null);
+__decorate([
+    (0, disallow_in_production_decorator_1.DisallowInProduction)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], ModulePackageService.prototype, "exportModulePackage", null);
+__decorate([
+    (0, disallow_in_production_decorator_1.DisallowInProduction)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, confirm_module_package_import_dto_1.ConfirmModulePackageImportDto]),
+    __metadata("design:returntype", Promise)
+], ModulePackageService.prototype, "confirmImport", null);
+__decorate([
+    (0, disallow_in_production_decorator_1.DisallowInProduction)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, run_module_package_build_dto_1.RunModulePackageBuildDto]),
+    __metadata("design:returntype", Promise)
+], ModulePackageService.prototype, "runBuild", null);
+__decorate([
+    (0, disallow_in_production_decorator_1.DisallowInProduction)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, run_module_package_seed_dto_1.RunModulePackageSeedDto]),
+    __metadata("design:returntype", Promise)
+], ModulePackageService.prototype, "runSeed", null);
+exports.ModulePackageService = ModulePackageService = ModulePackageService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [command_service_1.CommandService,
+        module_metadata_helper_service_1.ModuleMetadataHelperService])
+], ModulePackageService);
+//# sourceMappingURL=module-package.service.js.map