@celilo/cli 5.2.0 → 5.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@celilo/cli",
-  "version": "5.2.0",
+  "version": "5.2.1",
   "description": "Celilo — home lab orchestration CLI",
   "type": "module",
   "bin": {

package/src/policy/module-business-baseline.ts

@@ -345,12 +345,6 @@ export const CAPABILITY_NAME_BASELINE: readonly CapabilityNameRow[] = [
     count: 1,
     why: 'S13 — ZONE_REQUIREMENTS, a second hand-maintained copy of well-known.ts; Phase 2 (#937)',
   },
-  {
-    file: 'apps/celilo/src/templates/generator.ts',
-    capability: 'dns_internal',
-    count: 1,
-    why: 'X4 — declaration-driven and the model for the rest; only the error string names the capability (#945)',
-  },
   {
     file: 'apps/celilo/src/variables/context.ts',
     capability: 'dns_internal',

package/src/templates/copy-role-files.test.ts

@@ -21,9 +21,9 @@ import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { copyAnsibleRoleFilesDirs } from './generator';
 
-function moduleWithRoleFile(binary: string): string {
+function moduleWithRoleFile(binary: string, layout = 'ansible'): string {
   const root = mkdtempSync(join(tmpdir(), 'celilo-rolefiles-'));
-  const filesDir = join(root, 'ansible', 'roles', 'demo', 'files');
+  const filesDir = join(root, layout, 'roles', 'demo', 'files');
   mkdirSync(filesDir, { recursive: true });
   writeFileSync(join(filesDir, 'demo-linux-x86_64'), binary);
   return root;
@@ -59,6 +59,24 @@ describe('copyAnsibleRoleFilesDirs', () => {
     expect(generatedBinary(outputPath)).toBe('v2');
   });
 
+  /**
+   * celilo#1461. The template pipeline accepts BOTH `ansible/` and
+   * `celilo/ansible/`; this copy accepted one, so a celilo/-layout module got
+   * its role's tasks/ and templates/ and never its files/. `existsSync` was
+   * false, the function returned, and nothing anywhere said so.
+   *
+   * Generated output is the standard layout either way — the source layout is
+   * what varies.
+   */
+  test('finds role files/ under the celilo/ layout too', async () => {
+    const modulePath = moduleWithRoleFile('v1', 'celilo/ansible');
+    const outputPath = mkdtempSync(join(tmpdir(), 'celilo-out-'));
+
+    await copyAnsibleRoleFilesDirs(modulePath, outputPath);
+
+    expect(generatedBinary(outputPath)).toBe('v1');
+  });
+
   test('a module with no role files/ directory is not an error', async () => {
     const root = mkdtempSync(join(tmpdir(), 'celilo-norole-'));
     mkdirSync(join(root, 'ansible', 'roles', 'demo', 'tasks'), { recursive: true });

package/src/templates/generator.ts

@@ -60,9 +60,18 @@ const COPY_AS_IS_EXTENSIONS = ['.yml', '.yaml', '.tf'];
 /**
  * Template directories to process
  */
+// A module may keep its deployment tree at the root or under `celilo/`.
+// This is THE list of supported layouts — everything that has to find a
+// module's ansible/ or terraform/ derives it from here. celilo#1461 was two
+// functions deciding that independently and disagreeing.
+const LAYOUT_ROOTS = ['', 'celilo'];
+
+const layoutDirs = (name: string): string[] =>
+  LAYOUT_ROOTS.map((root) => (root ? `${root}/${name}` : name));
+
 // Directories to scan for template files. Supports both root-level and
 // celilo/ subdirectory layouts (e.g., ansible/ or celilo/ansible/).
-const TEMPLATE_DIRS = ['terraform', 'ansible', 'celilo/terraform', 'celilo/ansible'];
+const TEMPLATE_DIRS = [...layoutDirs('terraform'), ...layoutDirs('ansible')];
 
 /**
  * Check if file is a template that needs variable resolution
@@ -513,8 +522,9 @@ export async function readTemplateFiles(
  * @param files - Generated files to write
  */
 /**
- * Copy each `ansible/roles/<role>/files/` directory from the module source
- * to the generated output, verbatim (preserving binary content + mode bits).
+ * Copy each `<layout>/ansible/roles/<role>/files/` directory from the module
+ * source to the generated output, verbatim (preserving binary content + mode
+ * bits). Both supported layouts are scanned — see LAYOUT_ROOTS.
  *
  * These hold Ansible role-local static assets — they may be binaries and
  * don't need template variable resolution, so the standard template
@@ -524,38 +534,49 @@ export async function copyAnsibleRoleFilesDirs(
   modulePath: string,
   outputPath: string,
 ): Promise<void> {
-  const rolesDir = join(modulePath, 'ansible', 'roles');
-  if (!existsSync(rolesDir)) return;
-  const roles = await readdir(rolesDir, { withFileTypes: true });
-  for (const role of roles) {
-    if (!role.isDirectory()) continue;
-    const srcFilesDir = join(rolesDir, role.name, 'files');
-    if (!existsSync(srcFilesDir)) continue;
-    const destFilesDir = join(outputPath, 'ansible', 'roles', role.name, 'files');
-    await mkdir(dirname(destFilesDir), { recursive: true });
-    // `force: true` is LOAD-BEARING on bun, and its absence was celilo#925.
-    //
-    // Node defaults `force` to true, so this looked correct and is correct
-    // under Node. Bun 1.3.3 does not, on this path specifically — measured,
-    // copying "NEW" over an existing "OLD":
-    //
-    //   recursive only                          -> NEW
-    //   recursive + force                       -> NEW
-    //   recursive + preserveTimestamps          -> OLD   <- what this was
-    //   recursive + force + preserveTimestamps  -> NEW
-    //
-    // celilo runs on bun. So a module's built binary landed in `generated/`
-    // exactly once, at first generate, and no later version ever replaced it —
-    // silently, because `cp` reports no error, so the caller's try/catch has
-    // nothing to catch. Ansible then copies that first binary forever and
-    // reports `ok`, unchanged, while the module's version field advances.
-    //
-    // The sibling call in `storage-set-path.ts:153` already passes `force`.
-    await cp(srcFilesDir, destFilesDir, {
-      recursive: true,
-      force: true,
-      preserveTimestamps: true,
-    });
+  let copied = 0;
+  for (const ansibleDir of layoutDirs('ansible')) {
+    const rolesDir = join(modulePath, ansibleDir, 'roles');
+    if (!existsSync(rolesDir)) continue;
+    const roles = await readdir(rolesDir, { withFileTypes: true });
+    for (const role of roles) {
+      if (!role.isDirectory()) continue;
+      const srcFilesDir = join(rolesDir, role.name, 'files');
+      if (!existsSync(srcFilesDir)) continue;
+      const destFilesDir = join(outputPath, 'ansible', 'roles', role.name, 'files');
+      await mkdir(dirname(destFilesDir), { recursive: true });
+      // `force: true` is LOAD-BEARING on bun, and its absence was celilo#925.
+      //
+      // Node defaults `force` to true, so this looked correct and is correct
+      // under Node. Bun 1.3.3 does not, on this path specifically — measured,
+      // copying "NEW" over an existing "OLD":
+      //
+      //   recursive only                          -> NEW
+      //   recursive + force                       -> NEW
+      //   recursive + preserveTimestamps          -> OLD   <- what this was
+      //   recursive + force + preserveTimestamps  -> NEW
+      //
+      // celilo runs on bun. So a module's built binary landed in `generated/`
+      // exactly once, at first generate, and no later version ever replaced it —
+      // silently, because `cp` reports no error, so the caller's try/catch has
+      // nothing to catch. Ansible then copies that first binary forever and
+      // reports `ok`, unchanged, while the module's version field advances.
+      //
+      // The sibling call in `storage-set-path.ts:153` already passes `force`.
+      await cp(srcFilesDir, destFilesDir, {
+        recursive: true,
+        force: true,
+        preserveTimestamps: true,
+      });
+      copied++;
+    }
+  }
+
+  // "I looked and found nothing" must not read the same as "I copied
+  // everything". A module with no role files/ is legitimate; a module that has
+  // one somewhere this function cannot see is celilo#1461, and it was silent.
+  if (copied === 0) {
+    log.info(`No Ansible role files/ directories found under ${modulePath}`);
   }
 }