@smi-digital/create-smi-app 2.7.1 → 2.7.3

package/dist/index.js

@@ -92,16 +92,16 @@ function asFramework(value) {
 }
 
 // src/modules/integrations.ts
-import { readFile as readFile2, readdir } from "fs/promises";
-import { join as join2 } from "path";
+import { readFile, readdir } from "fs/promises";
+import { join } from "path";
 async function loadIntegrationConfig(templatesDir, integrationKey) {
-  const configPath = join2(
+  const configPath = join(
     templatesDir,
     "integrations",
     integrationKey,
     "integration.config.json"
   );
-  const rawContent = await readFile2(configPath, "utf8");
+  const rawContent = await readFile(configPath, "utf8");
   return JSON.parse(rawContent);
 }
 function matchesIntegration(selection, config) {
@@ -121,7 +121,7 @@ function matchesIntegration(selection, config) {
   return true;
 }
 async function getIntegrationForSelection(templatesDir, selection) {
-  const integrationsRoot = join2(templatesDir, "integrations");
+  const integrationsRoot = join(templatesDir, "integrations");
   const entries = await readdir(integrationsRoot, { withFileTypes: true });
   const folders = entries.filter((entry) => entry.isDirectory());
   const findSequentially = async (index) => {
@@ -274,17 +274,17 @@ async function askQuestions(templatesDir) {
 
 // src/modules/init.ts
 import { fileURLToPath } from "url";
-import { join as join3, dirname } from "path";
+import { join as join2, dirname } from "path";
 import { access } from "fs/promises";
 async function resolveTemplatesDir(currentDir) {
   const candidates = [
-    join3(currentDir, "../../templates"),
-    join3(currentDir, "../templates")
+    join2(currentDir, "../../templates"),
+    join2(currentDir, "../templates")
   ];
   const checks = await Promise.all(
     candidates.map(async (candidate) => {
       try {
-        await access(join3(candidate, "base"));
+        await access(join2(candidate, "base"));
         return true;
       } catch {
         return false;
@@ -314,8 +314,8 @@ import { access as access2, mkdir as mkdir2 } from "fs/promises";
 import { join as join6 } from "path";
 
 // src/modules/scaffoldActions/createTools.ts
-import { cp, readFile as readFile3, readdir as readdir2, writeFile as writeFile2 } from "fs/promises";
-import { join as join4 } from "path";
+import { cp, readFile as readFile2, readdir as readdir2, writeFile } from "fs/promises";
+import { join as join3 } from "path";
 var templateRenameMap = {
   "env.template": ".env",
   "gitignore.template": ".gitignore",
@@ -337,32 +337,32 @@ function toPackageName(projectName) {
   return normalized || "app";
 }
 async function updatePackageJsonName(targetDir, projectName) {
-  const packageJsonPath = join4(targetDir, "package.json");
-  const packageJsonRaw = await readFile3(packageJsonPath, "utf8");
+  const packageJsonPath = join3(targetDir, "package.json");
+  const packageJsonRaw = await readFile2(packageJsonPath, "utf8");
   const packageJson = JSON.parse(packageJsonRaw);
   packageJson.name = toPackageName(projectName);
-  await writeFile2(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}
+  await writeFile(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}
 `);
 }
 async function createTools(tools, targetDir, templatesDir, projectName) {
   if (!tools.includes("basic")) {
     return;
   }
-  const baseToolsDir = join4(templatesDir, "base");
-  const huskyDir = join4(templatesDir, ".husky");
+  const baseToolsDir = join3(templatesDir, "base");
+  const huskyDir = join3(templatesDir, ".husky");
   const entries = await readdir2(baseToolsDir, { withFileTypes: true });
   await Promise.all(
     entries.map(
       (entry) => cp(
-        join4(baseToolsDir, entry.name),
-        join4(targetDir, getTargetFileName(entry.name)),
+        join3(baseToolsDir, entry.name),
+        join3(targetDir, getTargetFileName(entry.name)),
         {
           recursive: true
         }
       )
     )
   );
-  await cp(huskyDir, join4(targetDir, ".husky"), {
+  await cp(huskyDir, join3(targetDir, ".husky"), {
     recursive: true
   });
   await updatePackageJsonName(targetDir, projectName);
@@ -424,7 +424,7 @@ async function runStep(label, task) {
     throw error;
   }
 }
-async function runCommandQuiet2(command, args, cwd) {
+async function runCommandQuiet(command, args, cwd) {
   await new Promise((resolve, reject) => {
     let stderr = "";
     const child = spawn(command, args, {
@@ -457,6 +457,8 @@ ${stderrTail}` : "";
 }
 
 // src/modules/scaffoldActions/createApps.ts
+import { join as join4 } from "path";
+import { readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
 async function createFrameworkApp(projectRoot, target) {
   const generator = FRAMEWORK_GENERATORS[target.framework];
   if (!generator) {
@@ -464,7 +466,7 @@ async function createFrameworkApp(projectRoot, target) {
   }
   await runStep(
     `Creating ${generator.displayName} ${target.label}`,
-    async () => runCommandQuiet2(
+    async () => runCommandQuiet(
       generator.command,
       generator.getArgs(target.directory),
       projectRoot
@@ -480,17 +482,17 @@ async function createApps(projectRoot, targets) {
     await createFrameworkApp(projectRoot, target);
     if (target.framework === "strapi") {
       try {
-        const pluginsPath = join(
+        const pluginsPath = join4(
           projectRoot,
           target.directory,
           "config/plugins.ts"
         );
-        let pluginsContent = await readFile(pluginsPath, "utf8");
+        let pluginsContent = await readFile3(pluginsPath, "utf8");
         pluginsContent = pluginsContent.replace(
           "export default ({ env }) => ({",
           "export default () => ({"
         );
-        await writeFile(pluginsPath, pluginsContent);
+        await writeFile2(pluginsPath, pluginsContent);
       } catch {
       }
     }
@@ -608,7 +610,10 @@ async function createIntegrations(options, projectRoot, templatesDir) {
         "export default defineConfig({\n  output: 'server',"
       );
       await writeFile3(astroConfigPath, astroConfig);
-    } catch {
+    } catch (error) {
+      console.warn(
+        `Could not configure the Astro SSR adapter automatically: ${error instanceof Error ? error.message : String(error)}`
+      );
     }
   });
 }
@@ -660,7 +665,7 @@ async function initializeGitRepository(projectRoot) {
   } catch {
   }
   try {
-    await runCommandQuiet2("git", ["init"], projectRoot);
+    await runCommandQuiet("git", ["init"], projectRoot);
   } catch {
     console.warn(
       "Git is not available. Husky hooks will activate after running git init."
@@ -673,7 +678,7 @@ async function activateVaultFilter(projectRoot) {
   } catch {
     return;
   }
-  const setFilter = async (key, value) => runCommandQuiet2(
+  const setFilter = async (key, value) => runCommandQuiet(
     "git",
     ["config", `filter.ansible-vault.${key}`, value],
     projectRoot
@@ -730,7 +735,7 @@ async function createScaffold(options, targetDir, templatesDir) {
   if (options.tools.includes("basic")) {
     await runStep(
       "Installing root dependencies",
-      async () => runCommandQuiet2("npm", ["install"], projectRoot)
+      async () => runCommandQuiet("npm", ["install"], projectRoot)
     );
   }
   console.log(accent2(`\u25C6 Project scaffolded at ${projectRoot}`));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smi-digital/create-smi-app",
-  "version": "2.7.1",
+  "version": "2.7.3",
   "description": "",
   "main": "dist/index.js",
   "bin": {

package/templates/integrations/strapi-astro/docker-compose.yml.template

@@ -61,7 +61,9 @@ services:
     depends_on:
       - __APP_NAME__-astro
     healthcheck:
-      test: ["CMD", "wget", "-q", "-O", "/dev/null", "http://localhost/"]
+      # Use 127.0.0.1 (not localhost): the read-only config mount blocks nginx's
+      # IPv6 listen, but busybox wget resolves localhost to ::1 first → refused.
+      test: ["CMD", "wget", "-q", "-O", "/dev/null", "http://127.0.0.1/healthz"]
       interval: 5s
       timeout: 2s
       retries: 5

package/templates/integrations/strapi-astro/nginx-cache.conf.template

@@ -7,6 +7,15 @@ server {
     gzip on;
     gzip_types text/plain text/css application/json application/javascript text/xml application/xml application/xml+rss text/javascript;
 
+    # Liveness endpoint for the container healthcheck. Returns 200 from nginx
+    # itself, so health reflects "the proxy is up" rather than the upstream
+    # homepage's status code.
+    location = /healthz {
+        access_log off;
+        add_header Content-Type text/plain;
+        return 200 "ok\n";
+    }
+
     location / {
         proxy_cache astro_cache;