container-superposition 0.1.8 → 0.1.10

package/dist/tool/questionnaire/composer.js

@@ -606,7 +606,7 @@ function validateImportPath(importPath, overlaysDir) {
 /**
  * Load and resolve imports from shared files for an overlay
  */
-function loadImportsForOverlay(overlayName, overlaysDir) {
+function loadImportsForOverlay(overlayName, overlaysDir, silent = false) {
     let importedConfig = {};
     // Load overlay manifest to get imports
     const overlayDir = path.join(overlaysDir, overlayName);
@@ -638,14 +638,16 @@ function loadImportsForOverlay(overlayName, overlaysDir) {
             const ext = path.extname(importPath).toLowerCase();
             if (ext === '.json') {
                 // JSON files are merged as devcontainer patches
-                console.log(chalk.dim(`   📎 Applying shared import: ${importPath}`));
+                if (!silent)
+                    console.log(chalk.dim(`   📎 Applying shared import: ${importPath}`));
                 const importedPatch = loadJson(fullImportPath);
                 importedConfig = deepMerge(importedConfig, importedPatch);
             }
             else if (ext === '.yaml' || ext === '.yml') {
                 // YAML files are loaded and merged as devcontainer patches
                 try {
-                    console.log(chalk.dim(`   📎 Applying shared import: ${importPath}`));
+                    if (!silent)
+                        console.log(chalk.dim(`   📎 Applying shared import: ${importPath}`));
                     const yamlContent = fs.readFileSync(fullImportPath, 'utf8');
                     const importedPatch = yaml.load(yamlContent);
                     if (importedPatch && typeof importedPatch === 'object') {
@@ -658,7 +660,8 @@ function loadImportsForOverlay(overlayName, overlaysDir) {
             }
             else if (ext === '.env') {
                 // .env files are handled separately during env merging — skip here
-                console.log(chalk.dim(`   📎 Shared .env import noted: ${importPath}`));
+                if (!silent)
+                    console.log(chalk.dim(`   📎 Shared .env import noted: ${importPath}`));
             }
             else {
                 // FR-007: Unsupported file types are errors
@@ -679,14 +682,16 @@ function loadImportsForOverlay(overlayName, overlaysDir) {
 /**
  * Apply an overlay to the base configuration
  */
-export function applyOverlay(baseConfig, overlayName, overlaysDir) {
+export function applyOverlay(baseConfig, overlayName, overlaysDir, options = {}) {
+    const { silent = false } = options;
     const overlayPath = path.join(overlaysDir, overlayName, 'devcontainer.patch.json');
     if (!fs.existsSync(overlayPath)) {
-        console.warn(chalk.yellow(`⚠️  Overlay not found: ${overlayName}`));
+        if (!silent)
+            console.warn(chalk.yellow(`⚠️  Overlay not found: ${overlayName}`));
         return baseConfig;
     }
     // First, load and apply any imports
-    const importedConfig = loadImportsForOverlay(overlayName, overlaysDir);
+    const importedConfig = loadImportsForOverlay(overlayName, overlaysDir, silent);
     if (Object.keys(importedConfig).length > 0) {
         baseConfig = deepMerge(baseConfig, importedConfig);
     }
@@ -728,8 +733,36 @@ class FileRegistry {
     }
 }
 /**
- * Clean up stale files from previous runs
- * Removes anything not in the registry (except preserved files like superposition.json)
+ * Recursively remove stale files within a registered subdirectory.
+ * Called for directories that ARE in the registry but may contain files from
+ * a previous run that are no longer part of the current generation (e.g.
+ * scripts/setup-rabbitmq.sh after rabbitmq was removed from the project).
+ * Returns the number of files removed.
+ */
+function cleanupStaleDirFiles(dirPath, prefix, expectedFiles) {
+    let removed = 0;
+    const entries = fs.readdirSync(dirPath);
+    for (const entry of entries) {
+        const entryPath = path.join(dirPath, entry);
+        const stat = fs.statSync(entryPath);
+        if (stat.isDirectory()) {
+            removed += cleanupStaleDirFiles(entryPath, `${prefix}${entry}/`, expectedFiles);
+        }
+        else {
+            const registryKey = `${prefix}${entry}`;
+            if (!expectedFiles.has(registryKey)) {
+                fs.unlinkSync(entryPath);
+                removed++;
+            }
+        }
+    }
+    return removed;
+}
+/**
+ * Clean up stale files from previous runs.
+ * Removes anything not in the registry (except preserved files like superposition.json).
+ * Also recurses into registered subdirectories to remove individual stale files within
+ * them — e.g. scripts/setup-rabbitmq.sh after rabbitmq is removed from the project.
  */
 function cleanupStaleFiles(outputPath, registry) {
     if (!fs.existsSync(outputPath)) {
@@ -753,11 +786,16 @@ function cleanupStaleFiles(outputPath, registry) {
             if (preservedDirs.has(entry)) {
                 continue;
             }
-            // Remove directory if not in registry
             if (!expectedDirs.has(entry)) {
+                // Remove directory entirely — nothing inside belongs to this run
                 fs.rmSync(entryPath, { recursive: true, force: true });
                 removedCount++;
             }
+            else {
+                // Directory is still expected, but individual files inside it may be stale
+                // (e.g. scripts/setup-rabbitmq.sh after rabbitmq was removed)
+                removedCount += cleanupStaleDirFiles(entryPath, `${entry}/`, expectedFiles);
+            }
         }
         else {
             // Remove file if not in registry
@@ -790,6 +828,23 @@ function copyDir(src, dest) {
         }
     }
 }
+/**
+ * Recursively register every file inside a directory in the FileRegistry.
+ * Used after copyDir() to ensure cleanup logic doesn't delete the copied contents.
+ */
+function registerDirContents(registry, dirPath, prefix) {
+    if (!fs.existsSync(dirPath))
+        return;
+    for (const entry of fs.readdirSync(dirPath, { withFileTypes: true })) {
+        const rel = `${prefix}${entry.name}`;
+        if (entry.isDirectory()) {
+            registerDirContents(registry, path.join(dirPath, entry.name), `${rel}/`);
+        }
+        else {
+            registry.addFile(rel);
+        }
+    }
+}
 /**
  * Copy additional files from overlay to output directory
  * Excludes devcontainer.patch.json and .env.example (handled separately)
@@ -832,6 +887,9 @@ function copyOverlayFiles(outputPath, overlayName, registry, overlaysDir) {
             const destPath = path.join(outputPath, destDirName);
             copyDir(srcPath, destPath);
             registry.addDirectory(destDirName);
+            // Register every file inside the copied directory so that
+            // cleanupStaleDirFiles does not delete them during the same run.
+            registerDirContents(registry, destPath, `${destDirName}/`);
             copiedFiles++;
         }
     }
@@ -946,6 +1004,178 @@ function applyProjectEnvToDevcontainer(config, projectEnv, stack, rootEnv) {
     console.log(chalk.dim(`   🌱 Applying project env to remoteEnv`));
     return deepMerge(config, { remoteEnv });
 }
+/**
+ * Resolve the abstract `ProjectMountTarget` to a concrete destination.
+ *
+ * - `devcontainerMount` — always routes to `devcontainer.json mounts[]`
+ * - `composeVolume` — always routes to `docker-compose.yml services.devcontainer.volumes[]`;
+ *   throws if the stack is not `compose` (no docker-compose.yml is generated for plain stacks)
+ * - `auto` (default) — always routes to `devcontainer.json mounts[]` regardless of stack,
+ *   so that the same `superposition.yml` works unchanged when swapping `stack: plain` ↔ `stack: compose`
+ *
+ * @throws {Error} When `composeVolume` is requested on a non-compose stack
+ */
+function resolveProjectMountTarget(mount, stack) {
+    const target = mount.target ?? 'auto';
+    if (target === 'composeVolume') {
+        if (stack !== 'compose') {
+            throw new Error('Project mount target "composeVolume" requires stack: compose because no docker-compose.yml is generated for plain stacks');
+        }
+        return 'composeVolume';
+    }
+    // Both 'auto' (default) and explicit 'devcontainerMount' are treated identically:
+    // always route to devcontainer.json mounts[] regardless of stack
+    return 'devcontainerMount';
+}
+function boolToReadonlyFlag(value) {
+    return value ? ',readonly' : '';
+}
+function buildConsistencyValue(mount) {
+    if (mount.cached) {
+        return 'cached';
+    }
+    return mount.consistency;
+}
+function toDevcontainerMountSpec(mount) {
+    if (mount.value) {
+        return mount.value;
+    }
+    const source = mount.source?.trim();
+    const destination = mount.destination?.trim();
+    if (!source || !destination) {
+        throw new Error('Structured project mounts require both "source" and "destination" when no raw "value" is provided');
+    }
+    const type = mount.type ?? 'bind';
+    const consistency = buildConsistencyValue(mount);
+    return `source=${source},target=${destination},type=${type}${consistency ? `,consistency=${consistency}` : ''}${boolToReadonlyFlag(mount.readOnly)}`;
+}
+function toComposeVolumeSpec(mount) {
+    if (mount.value) {
+        return mount.value;
+    }
+    const source = mount.source?.trim();
+    const destination = mount.destination?.trim();
+    if (!source || !destination) {
+        throw new Error('Structured project mounts require both "source" and "destination" when no raw "value" is provided');
+    }
+    const options = [];
+    if (mount.readOnly) {
+        options.push('ro');
+    }
+    const consistency = buildConsistencyValue(mount);
+    if (consistency) {
+        options.push(consistency);
+    }
+    return options.length > 0
+        ? `${source}:${destination}:${options.join(',')}`
+        : `${source}:${destination}`;
+}
+/**
+ * Merge project mounts destined for `devcontainer.json` into the devcontainer config.
+ *
+ * Filters the `projectMounts` list to entries whose resolved target is `devcontainerMount`
+ * (i.e. explicit `target: devcontainerMount`, or `target: auto`), then
+ * deepMerge-concatenates their values into `config.mounts[]`. Returns early unchanged if
+ * no applicable mounts exist.
+ */
+function applyProjectMountsToDevcontainer(config, projectMounts, stack) {
+    if (!projectMounts?.length) {
+        return config;
+    }
+    const devcontainerMounts = projectMounts
+        .filter((m) => resolveProjectMountTarget(m, stack) === 'devcontainerMount')
+        .map(toDevcontainerMountSpec);
+    if (devcontainerMounts.length === 0) {
+        return config;
+    }
+    console.log(chalk.dim(`   🗂️  Applying project mounts to devcontainer.json`));
+    return deepMerge(config, { mounts: devcontainerMounts });
+}
+/**
+ * Extract mount values destined for `docker-compose.yml services.devcontainer.volumes[]`.
+ *
+ * Returns the raw value strings for all mounts whose resolved target is `composeVolume`
+ * (i.e. explicit `target: composeVolume` only). The caller is responsible for merging the
+ * returned array into the compose service definition.
+ */
+function buildComposeProjectMountVolumes(projectMounts, stack) {
+    if (!projectMounts?.length) {
+        return [];
+    }
+    return projectMounts
+        .filter((m) => resolveProjectMountTarget(m, stack) === 'composeVolume')
+        .map(toComposeVolumeSpec);
+}
+function quoteShellSingle(value) {
+    return `'${value.replace(/'/g, `'\"'\"'`)}'`;
+}
+function applyProjectShellConfig(config, projectShell, outputPath, fileRegistry) {
+    if (!projectShell) {
+        return config;
+    }
+    const aliases = projectShell.aliases ?? {};
+    const snippets = projectShell.snippets ?? [];
+    if (Object.keys(aliases).length === 0 && snippets.length === 0) {
+        return config;
+    }
+    const scriptsDir = path.join(outputPath, 'scripts');
+    fs.mkdirSync(scriptsDir, { recursive: true });
+    fileRegistry.addDirectory('scripts');
+    const shellInitPath = path.join(scriptsDir, 'shell-init.sh');
+    const aliasLines = Object.entries(aliases)
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(([name, cmd]) => `alias ${name}=${quoteShellSingle(cmd)}`);
+    const shellInit = [
+        '#!/usr/bin/env bash',
+        '# Generated by container-superposition from superposition.yml:shell',
+        ...aliasLines,
+        ...(snippets.length > 0 ? ['', ...snippets] : []),
+        '',
+    ].join('\n');
+    fs.writeFileSync(shellInitPath, shellInit, 'utf8');
+    fileRegistry.addFile('scripts/shell-init.sh');
+    const hookScriptPath = path.join(scriptsDir, 'setup-project-shell.sh');
+    const hookScript = `#!/usr/bin/env bash
+set -e
+BEGIN_MARKER="# >>> container-superposition shell >>>"
+END_MARKER="# <<< container-superposition shell <<<"
+DEVCONTAINER_DIR="$(cd "$(dirname "\${BASH_SOURCE[0]}")/.." && pwd)"
+SHELL_INIT_FILE="\${DEVCONTAINER_DIR}/scripts/shell-init.sh"
+
+install_hook() {
+    local rc_file="$1"
+    touch "$rc_file"
+    local tmp_file
+    tmp_file="$(mktemp)"
+    awk -v b="$BEGIN_MARKER" -v e="$END_MARKER" '
+        $0==b {skip=1; next}
+        $0==e {skip=0; next}
+        !skip {print}
+    ' "$rc_file" > "$tmp_file"
+    cat >> "$tmp_file" <<EOF
+$BEGIN_MARKER
+[ -f "$SHELL_INIT_FILE" ] && source "$SHELL_INIT_FILE"
+$END_MARKER
+EOF
+    mv "$tmp_file" "$rc_file"
+}
+
+install_hook "$HOME/.bashrc"
+install_hook "$HOME/.zshrc"
+`;
+    fs.writeFileSync(hookScriptPath, hookScript, { mode: 0o755 });
+    fileRegistry.addFile('scripts/setup-project-shell.sh');
+    if (!config.postCreateCommand) {
+        config.postCreateCommand = {};
+    }
+    if (typeof config.postCreateCommand === 'string') {
+        config.postCreateCommand = { default: config.postCreateCommand };
+    }
+    config.postCreateCommand['setup-project-shell'] =
+        'bash .devcontainer/scripts/setup-project-shell.sh';
+    console.log(chalk.dim(`   🐚 Applying project shell aliases/snippets`));
+    return config;
+}
 function mergeComposeEnvFile(outputPath, entries) {
     if (Object.keys(entries).length === 0) {
         return false;
@@ -1269,7 +1499,7 @@ function resolveDockerComposePortConflicts(services) {
 /**
  * Merge docker-compose.yml files from base and overlays into a single file
  */
-function mergeDockerComposeFiles(outputPath, baseStack, overlays, overlaysDir, portOffset, customImage, projectEnv) {
+function mergeDockerComposeFiles(outputPath, baseStack, overlays, overlaysDir, portOffset, customImage, projectEnv, projectMounts) {
     const composeFiles = [];
     // Add base docker-compose if exists
     const baseComposePath = path.join(TEMPLATES_DIR, baseStack, '.devcontainer', 'docker-compose.yml');
@@ -1353,6 +1583,16 @@ function mergeDockerComposeFiles(outputPath, baseStack, overlays, overlaysDir, p
             merged.services.devcontainer.environment = deepMerge(merged.services.devcontainer.environment ?? {}, composeEnv);
             console.log(chalk.dim(`   🌱 Applying project env to docker-compose devcontainer service`));
         }
+        const composeMountVolumes = buildComposeProjectMountVolumes(projectMounts, baseStack);
+        if (composeMountVolumes.length > 0) {
+            const existing = Array.isArray(merged.services.devcontainer.volumes)
+                ? merged.services.devcontainer.volumes
+                : [];
+            merged.services.devcontainer.volumes = [
+                ...new Set([...existing, ...composeMountVolumes]),
+            ];
+            console.log(chalk.dim(`   🗂️  Applying project mounts to docker-compose devcontainer service`));
+        }
         if (customImage) {
             // Apply custom base image if specified
             merged.services.devcontainer.image = customImage;
@@ -1776,6 +2016,7 @@ export async function composeDevContainer(answers, overlaysDir, options = {}) {
         config = applyOverlay(config, overlay, actualOverlaysDir);
     }
     config = applyProjectEnvToDevcontainer(config, answers.projectEnv, answers.stack, rootEnv);
+    config = applyProjectMountsToDevcontainer(config, answers.projectMounts, answers.stack);
     // 7. Copy template files (docker-compose, scripts, etc.)
     const entries = fs.readdirSync(templatePath);
     for (const entry of entries) {
@@ -1799,11 +2040,19 @@ export async function composeDevContainer(answers, overlaysDir, options = {}) {
     }
     // 8.5. Copy cross-distro-packages feature if used
     if (config.features?.['./features/cross-distro-packages']) {
-        const featuresDir = path.join(outputPath, 'features', 'cross-distro-packages');
-        const sourceFeatureDir = path.join(REPO_ROOT, 'features', 'cross-distro-packages');
+        const featureName = 'cross-distro-packages';
+        const featuresDir = path.join(outputPath, 'features', featureName);
+        const sourceFeatureDir = path.join(REPO_ROOT, 'features', featureName);
         if (fs.existsSync(sourceFeatureDir)) {
             copyDir(sourceFeatureDir, featuresDir);
             fileRegistry.addDirectory('features');
+            // Register every file inside the feature so cleanupStaleDirFiles
+            // does not remove them when it recurses into the 'features' directory.
+            for (const f of fs.readdirSync(sourceFeatureDir)) {
+                if (fs.statSync(path.join(sourceFeatureDir, f)).isFile()) {
+                    fileRegistry.addFile(`features/${featureName}/${f}`);
+                }
+            }
             console.log(chalk.dim(`   📦 Copied cross-distro-packages feature`));
         }
     }
@@ -1815,7 +2064,7 @@ export async function composeDevContainer(answers, overlaysDir, options = {}) {
     let composePortRemappings = [];
     if (answers.stack === 'compose') {
         const customImage = config._customImage;
-        composePortRemappings = mergeDockerComposeFiles(outputPath, answers.stack, overlays, actualOverlaysDir, answers.portOffset, customImage, answers.projectEnv);
+        composePortRemappings = mergeDockerComposeFiles(outputPath, answers.stack, overlays, actualOverlaysDir, answers.portOffset, customImage, answers.projectEnv, answers.projectMounts);
         // Update devcontainer.json to reference the combined file
         if (config.dockerComposeFile) {
             config.dockerComposeFile = 'docker-compose.yml';
@@ -1838,6 +2087,7 @@ export async function composeDevContainer(answers, overlaysDir, options = {}) {
     }
     // Merge setup scripts from overlays into postCreateCommand
     mergeSetupScripts(config, overlays, outputPath, fileRegistry, actualOverlaysDir);
+    config = applyProjectShellConfig(config, answers.projectShell, outputPath, fileRegistry);
     // 10. Apply custom patches from .devcontainer/custom/ (if present)
     const customPatches = loadCustomPatches(outputPath);
     if (customPatches) {
@@ -2155,15 +2405,14 @@ function applyPortOffsetToDevcontainer(config, offset) {
 function mergeSetupScripts(config, overlays, outputPath, fileRegistry, overlaysDir) {
     const setupScripts = [];
     const verifyScripts = [];
-    // Create scripts subfolder
     const scriptsDir = path.join(outputPath, 'scripts');
-    if (!fs.existsSync(scriptsDir)) {
-        fs.mkdirSync(scriptsDir, { recursive: true });
-    }
-    // Add scripts directory to registry if any scripts will be added
+    // Only create the scripts directory (and register it) if at least one overlay needs it
     const hasScripts = overlays.some((o) => fs.existsSync(path.join(overlaysDir, o, 'setup.sh')) ||
         fs.existsSync(path.join(overlaysDir, o, 'verify.sh')));
     if (hasScripts) {
+        if (!fs.existsSync(scriptsDir)) {
+            fs.mkdirSync(scriptsDir, { recursive: true });
+        }
         fileRegistry.addDirectory('scripts');
         // Emit shared setup utilities so overlay scripts can source them
         const setupUtilsSrc = path.join(TEMPLATES_DIR, 'scripts', 'setup-utils.sh');
@@ -2291,7 +2540,11 @@ function mergeRunServices(config, overlays, overlaysDir) {
         if (fs.existsSync(overlayPath)) {
             const overlayConfig = loadJson(overlayPath);
             if (overlayConfig.runServices) {
-                const order = overlayConfig._serviceOrder || 0;
+                const manifestPath = path.join(overlaysDir, overlay, 'overlay.yml');
+                const manifest = fs.existsSync(manifestPath)
+                    ? yaml.load(fs.readFileSync(manifestPath, 'utf8'))
+                    : null;
+                const order = manifest?.serviceOrder ?? 0;
                 for (const service of overlayConfig.runServices) {
                     services.push({ name: service, order });
                 }