@getstrata/starter 0.1.10 → 0.1.12

package/README.md

@@ -1,6 +1,6 @@
 # create-strata
 
-Interactive starter for [Strata](https://github.com/EyK-26/strata). The wizard always asks each layer. SQLite APIs and Postgres HTML apps use the same generator.
+Interactive starter for [Strata](https://github.com/EyK-26/strata). The wizard always asks each layer. Extras (MFA, email verification, SCIM, metrics) are toggled one by one. SQLite APIs and Postgres HTML apps use the same generator.
 
 ## Usage
 
@@ -12,7 +12,7 @@ bunx create-strata html --frontend server-htmx --database postgres --auth cookie
 
 Layer flags: `--frontend`, `--database`, `--auth`, `--tenancy`, `--cache`, `--queue`, `--mail`, `--spa-prefix`, plus extras (`--mfa`, `--scim`, `--metrics`, ...).
 
-Pick **one** database engine. Docker Compose is optional and only includes services for the tools you selected (`--docker`, `--no-docker`, `--docker-services=postgres,redis`).
+Pick **one** database engine. Docker Compose is optional and only includes services for the tools you selected (`--docker`, `--no-docker`, `--docker-services=postgres,redis`). `--docker` with Postgres or MySQL also writes Adminer.
 
 ## What you get
 

package/dist/cli.js

@@ -84,12 +84,13 @@ var TENANCY_DRIVERS = ["none", "column", "rls"];
 var CACHE_DRIVERS = ["array", "redis"];
 var QUEUE_DRIVERS = ["sync", "redis"];
 var MAIL_DRIVERS = ["log", "smtp"];
-var DOCKER_SERVICE_NAMES = ["postgres", "mysql", "redis", "mailpit"];
+var DOCKER_SERVICE_NAMES = ["postgres", "mysql", "redis", "mailpit", "adminer"];
 var DOCKER_SERVICE_LABELS = {
   postgres: "Postgres",
   mysql: "MySQL",
   redis: "Redis",
-  mailpit: "SMTP (Mailpit)"
+  mailpit: "SMTP (Mailpit)",
+  adminer: "Adminer (database UI)"
 };
 function authUsesCookie(auth) {
   return auth === "cookie" || auth.startsWith("cookie-");
@@ -109,11 +110,26 @@ function usesTenantTable(tenancy) {
 function htmlAuthKit(auth) {
   return authUsesCookie(auth);
 }
+function extraApplies(extra, auth) {
+  if (extra === "metrics") {
+    return true;
+  }
+  if (extra === "mfa") {
+    return htmlAuthKit(auth);
+  }
+  return authNeedsUsers(auth);
+}
 function needsRedis(layers) {
   return layers.cache === "redis" || layers.queue === "redis";
 }
 function emptyDockerServices() {
-  return { postgres: false, mysql: false, redis: false, mailpit: false };
+  return { postgres: false, mysql: false, redis: false, mailpit: false, adminer: false };
+}
+function dockerDatabaseService(database) {
+  if (database === "postgres" || database === "mysql") {
+    return database;
+  }
+  return null;
 }
 function enableDockerServices(names) {
   const services = emptyDockerServices();
@@ -142,7 +158,12 @@ function selectedDockerServices(layers) {
   if (!layers.docker.enabled) {
     return [];
   }
-  return neededDockerServices(layers).filter((name) => layers.docker.services[name]);
+  const selected = neededDockerServices(layers).filter((name) => layers.docker.services[name]);
+  const databaseService = dockerDatabaseService(layers.database);
+  if (databaseService && selected.includes(databaseService) && layers.docker.services.adminer) {
+    selected.push("adminer");
+  }
+  return selected;
 }
 function reconcileDocker(layers) {
   const selected = selectedDockerServices(layers);
@@ -159,7 +180,11 @@ function dockerLayerForNeeded(layers, enabled) {
   if (!enabled || needed.length === 0) {
     return { enabled: false, services: emptyDockerServices() };
   }
-  return { enabled: true, services: enableDockerServices(needed) };
+  const names = [...needed];
+  if (dockerDatabaseService(layers.database)) {
+    names.push("adminer");
+  }
+  return { enabled: true, services: enableDockerServices(names) };
 }
 
 // src/presets.ts
@@ -240,10 +265,10 @@ Options:
   --email-verification / --no-email-verification
   --scim / --no-scim
   --metrics / --no-metrics
-  --extras            Prompt (or enable) MFA, email verification, SCIM, metrics
+  --extras            Interactive extras list (MFA, email verification, SCIM, metrics)
   --docker            Write Docker Compose for every selected tool that needs a service
   --no-docker         Skip docker-compose.yml; use installs already on this machine
-  --docker-services   Subset: postgres, mysql, redis, mailpit (comma-separated)
+  --docker-services   Subset: postgres, mysql, redis, mailpit, adminer (comma-separated)
   --force             Replace an existing directory
   --yes, --no-interactive
   -h, --help
@@ -437,7 +462,13 @@ function applyDockerFlags(layers, flags) {
     };
   }
   if (flags.dockerServices) {
-    const selected = flags.dockerServices.filter((name) => needed.includes(name));
+    const databaseService = dockerDatabaseService(layers.database);
+    const selected = flags.dockerServices.filter((name) => {
+      if (needed.includes(name)) {
+        return true;
+      }
+      return name === "adminer" && databaseService !== null && flags.dockerServices?.includes(databaseService) === true;
+    });
     return {
       ...layers,
       docker: {
@@ -479,14 +510,355 @@ function layersFromFlags(flags) {
 // src/prompt.ts
 import { stdin as input, stdout as output } from "process";
 import { createInterface } from "readline/promises";
+
+// src/selectPrompt.ts
+class PromptCancelledError extends Error {
+  constructor() {
+    super("Cancelled");
+    this.name = "PromptCancelledError";
+  }
+}
+function consumeSelectKeys(buffer) {
+  const events = [];
+  let rest = buffer;
+  while (rest.length > 0) {
+    if (rest[0] === "\x1B") {
+      if (rest.length === 1) {
+        break;
+      }
+      if (rest.startsWith("\x1B[")) {
+        const end = rest.search(/[A-Za-z]/);
+        if (end < 2) {
+          break;
+        }
+        const command = rest[end];
+        rest = rest.slice(end + 1);
+        if (command === "A") {
+          events.push({ type: "up" });
+        } else if (command === "B") {
+          events.push({ type: "down" });
+        } else if (command === "C") {
+          events.push({ type: "right" });
+        } else if (command === "D") {
+          events.push({ type: "left" });
+        }
+        continue;
+      }
+      if (rest.startsWith("\x1BO")) {
+        if (rest.length < 3) {
+          break;
+        }
+        const command = rest[2];
+        rest = rest.slice(3);
+        if (command === "A") {
+          events.push({ type: "up" });
+        } else if (command === "B") {
+          events.push({ type: "down" });
+        } else if (command === "C") {
+          events.push({ type: "right" });
+        } else if (command === "D") {
+          events.push({ type: "left" });
+        }
+        continue;
+      }
+      rest = rest.slice(1);
+      events.push({ type: "abort" });
+      continue;
+    }
+    const next = rest[0] ?? "";
+    rest = rest.slice(1);
+    if (next === "\x03") {
+      events.push({ type: "abort" });
+      continue;
+    }
+    if (next === "\r" || next === `
+`) {
+      events.push({ type: "submit" });
+      continue;
+    }
+    if (next === " ") {
+      events.push({ type: "toggle" });
+      continue;
+    }
+    if (next === "y" || next === "Y") {
+      events.push({ type: "yes" });
+      continue;
+    }
+    if (next === "n" || next === "N") {
+      events.push({ type: "no" });
+      continue;
+    }
+    if (next >= "1" && next <= "9") {
+      events.push({ type: "digit", value: Number(next) });
+    }
+  }
+  return { events, rest };
+}
+function moveSelectIndex(index, delta, length) {
+  if (length <= 0) {
+    return 0;
+  }
+  return (index + delta + length) % length;
+}
+function highlight(line, on) {
+  return on ? `\x1B[7m${line}\x1B[0m` : line;
+}
+function renderSelectLines(message, choices, index) {
+  return [
+    message,
+    ...choices.map((choice, choiceIndex) => {
+      const selected = choiceIndex === index;
+      const marker = selected ? ">" : " ";
+      return highlight(`  ${marker} ${choiceIndex + 1}) ${choice.label}`, selected);
+    }),
+    `  \u2191/\u2193 and Enter, or 1-${choices.length}`
+  ];
+}
+function renderConfirmLines(message, yes) {
+  return [
+    message,
+    highlight(`  ${yes ? ">" : " "} yes`, yes),
+    highlight(`  ${yes ? " " : ">"} no`, !yes),
+    "  \u2191/\u2193 and Enter, or y / n"
+  ];
+}
+function renderMultiSelectLines(message, choices, index) {
+  return [
+    message,
+    ...choices.map((choice, choiceIndex) => {
+      const focused = choiceIndex === index;
+      const box = choice.enabled ? "[x]" : "[ ]";
+      const marker = focused ? ">" : " ";
+      return highlight(`  ${marker} ${box} ${choiceIndex + 1}) ${choice.label}`, focused);
+    }),
+    "  \u2191/\u2193 move, Space or 1-9 toggle, Enter to continue"
+  ];
+}
+function writeLines(output, lines) {
+  for (const line of lines) {
+    output.write(`\x1B[2K${line}
+`);
+  }
+}
+function clearDrawnLines(output, lineCount) {
+  if (lineCount <= 0) {
+    return;
+  }
+  output.write(`\x1B[${lineCount}F`);
+  for (let i = 0;i < lineCount; i += 1) {
+    output.write(`\x1B[2K
+`);
+  }
+  output.write(`\x1B[${lineCount}F`);
+}
+function runRawPrompt(io, render, onEvent, summary) {
+  const { input, output } = io;
+  const wasRaw = Boolean(input.isTTY && typeof input.setRawMode === "function");
+  let buffer = "";
+  let lineCount = 0;
+  let settled = false;
+  const restore = () => {
+    output.write("\x1B[?25h");
+    if (wasRaw) {
+      input.setRawMode?.(false);
+    }
+  };
+  const paint = () => {
+    const lines = render();
+    if (lineCount > 0) {
+      output.write(`\x1B[${lineCount}F`);
+    }
+    writeLines(output, lines);
+    lineCount = lines.length;
+  };
+  input.setEncoding("utf8");
+  if (wasRaw) {
+    input.setRawMode?.(true);
+  }
+  if (typeof input.resume === "function") {
+    input.resume();
+  }
+  output.write("\x1B[?25l");
+  paint();
+  return new Promise((resolve, reject) => {
+    const cleanup = () => {
+      input.off("data", onData);
+      restore();
+    };
+    const succeed = (result) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      cleanup();
+      clearDrawnLines(output, lineCount);
+      output.write(`${summary(result)}
+`);
+      resolve(result);
+    };
+    const fail = (error) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      cleanup();
+      clearDrawnLines(output, lineCount);
+      reject(error);
+    };
+    function onData(chunk) {
+      buffer += typeof chunk === "string" ? chunk : chunk.toString("utf8");
+      const consumed = consumeSelectKeys(buffer);
+      buffer = consumed.rest;
+      for (const event of consumed.events) {
+        const outcome = onEvent(event);
+        if (outcome === "abort") {
+          fail(new PromptCancelledError);
+          return;
+        }
+        if (outcome === "continue") {
+          paint();
+          continue;
+        }
+        succeed(outcome.done);
+        return;
+      }
+    }
+    input.on("data", onData);
+  });
+}
+async function promptSelect(message, choices, defaultValue, io) {
+  if (choices.length === 0) {
+    throw new Error(`No choices for "${message}".`);
+  }
+  const found = choices.findIndex((choice) => choice.value === defaultValue);
+  let index = found >= 0 ? found : 0;
+  return runRawPrompt(io, () => renderSelectLines(message, choices, index), (event) => {
+    if (event.type === "abort") {
+      return "abort";
+    }
+    if (event.type === "up") {
+      index = moveSelectIndex(index, -1, choices.length);
+      return "continue";
+    }
+    if (event.type === "down") {
+      index = moveSelectIndex(index, 1, choices.length);
+      return "continue";
+    }
+    if (event.type === "digit") {
+      if (event.value >= 1 && event.value <= choices.length) {
+        const choice = choices[event.value - 1];
+        if (choice) {
+          return { done: choice.value };
+        }
+      }
+      return "continue";
+    }
+    if (event.type === "submit") {
+      const choice = choices[index];
+      if (choice) {
+        return { done: choice.value };
+      }
+    }
+    return "continue";
+  }, (value) => `${message}  ${choices.find((choice) => choice.value === value)?.label ?? value}`);
+}
+async function promptConfirm(message, defaultValue, io) {
+  let yes = defaultValue;
+  return runRawPrompt(io, () => renderConfirmLines(message, yes), (event) => {
+    if (event.type === "abort") {
+      return "abort";
+    }
+    if (event.type === "up" || event.type === "right" || event.type === "yes") {
+      if (event.type === "yes") {
+        return { done: true };
+      }
+      yes = true;
+      return "continue";
+    }
+    if (event.type === "down" || event.type === "left" || event.type === "no") {
+      if (event.type === "no") {
+        return { done: false };
+      }
+      yes = false;
+      return "continue";
+    }
+    if (event.type === "digit") {
+      if (event.value === 1) {
+        return { done: true };
+      }
+      if (event.value === 2) {
+        return { done: false };
+      }
+    }
+    if (event.type === "submit") {
+      return { done: yes };
+    }
+    return "continue";
+  }, (value) => `${message}  ${value ? "yes" : "no"}`);
+}
+async function promptMultiSelect(message, choices, io) {
+  if (choices.length === 0) {
+    return [];
+  }
+  const selected = choices.map((choice) => choice.enabled);
+  let index = 0;
+  const enabledValues = () => choices.filter((_, choiceIndex) => selected[choiceIndex]).map((choice) => choice.value);
+  return runRawPrompt(io, () => renderMultiSelectLines(message, choices.map((choice, choiceIndex) => ({
+    ...choice,
+    enabled: Boolean(selected[choiceIndex])
+  })), index), (event) => {
+    if (event.type === "abort") {
+      return "abort";
+    }
+    if (event.type === "up") {
+      index = moveSelectIndex(index, -1, choices.length);
+      return "continue";
+    }
+    if (event.type === "down") {
+      index = moveSelectIndex(index, 1, choices.length);
+      return "continue";
+    }
+    if (event.type === "toggle") {
+      selected[index] = !selected[index];
+      return "continue";
+    }
+    if (event.type === "digit") {
+      if (event.value >= 1 && event.value <= choices.length) {
+        const target = event.value - 1;
+        selected[target] = !selected[target];
+        index = target;
+      }
+      return "continue";
+    }
+    if (event.type === "submit") {
+      return { done: enabledValues() };
+    }
+    return "continue";
+  }, (values) => {
+    const labels = choices.filter((choice) => values.includes(choice.value)).map((choice) => choice.value);
+    return `${message}  ${labels.length > 0 ? labels.join(", ") : "none"}`;
+  });
+}
+
+// src/prompt.ts
+var EXTRA_CHOICES = [
+  { value: "mfa", label: "mfa: authenticator challenge + setup pages" },
+  { value: "emailVerification", label: "email-verification: signed links + /email/verify" },
+  { value: "scim", label: "scim: /Users adapter" },
+  { value: "metrics", label: "metrics: Prometheus token" }
+];
 function isInteractive(flags) {
   if (flags.yes || flags.noInteractive) {
     return false;
   }
   return Boolean(input.isTTY && output.isTTY);
 }
+function canUseRawKeys() {
+  return Boolean(input.isTTY && typeof input.setRawMode === "function");
+}
 function createReadlinePrompter() {
   const rl = createInterface({ input, output });
+  const io = { input, output };
   return {
     async question(message, defaultValue) {
       const suffix = defaultValue ? ` [${defaultValue}]` : "";
@@ -494,6 +866,15 @@ function createReadlinePrompter() {
       return answer || defaultValue || "";
     },
     async confirm(message, defaultValue = false) {
+      if (canUseRawKeys()) {
+        rl.pause();
+        try {
+          return await promptConfirm(message, defaultValue, io);
+        } finally {
+          input.setRawMode?.(false);
+          rl.resume();
+        }
+      }
       const hint = defaultValue ? "Y/n" : "y/N";
       const answer = (await rl.question(`${message} (${hint}): `)).trim().toLowerCase();
       if (!answer) {
@@ -502,6 +883,15 @@ function createReadlinePrompter() {
       return answer === "y" || answer === "yes";
     },
     async select(message, choices, defaultValue) {
+      if (canUseRawKeys()) {
+        rl.pause();
+        try {
+          return await promptSelect(message, choices, defaultValue, io);
+        } finally {
+          input.setRawMode?.(false);
+          rl.resume();
+        }
+      }
       console.log(message);
       for (const [index, choice] of choices.entries()) {
         const marker = choice.value === defaultValue ? "*" : " ";
@@ -520,11 +910,66 @@ function createReadlinePrompter() {
       const match = choices.find((choice) => choice.value === answer || choice.label === answer);
       return match?.value ?? defaultValue;
     },
+    async multiSelect(message, choices) {
+      if (canUseRawKeys()) {
+        rl.pause();
+        try {
+          return await promptMultiSelect(message, choices, io);
+        } finally {
+          input.setRawMode?.(false);
+          rl.resume();
+        }
+      }
+      const enabled = new Set(choices.filter((choice) => choice.enabled).map((choice) => choice.value));
+      console.log(`${message} (yes/no each)`);
+      for (const choice of choices) {
+        const hint = enabled.has(choice.value) ? "Y/n" : "y/N";
+        const answer = (await rl.question(`  ${choice.label} (${hint}): `)).trim().toLowerCase();
+        if (!answer) {
+          continue;
+        }
+        if (answer === "y" || answer === "yes") {
+          enabled.add(choice.value);
+        } else if (answer === "n" || answer === "no") {
+          enabled.delete(choice.value);
+        }
+      }
+      return [...enabled];
+    },
     close() {
       rl.close();
     }
   };
 }
+function extrasStillToAsk(layers, flags) {
+  return EXTRA_CHOICES.filter((choice) => {
+    if (flags.extras[choice.value] !== undefined) {
+      return false;
+    }
+    return extraApplies(choice.value, layers.auth);
+  });
+}
+async function promptExtras(prompter, extras, layers, flags) {
+  const choices = extrasStillToAsk(layers, flags);
+  if (choices.length === 0) {
+    return extras;
+  }
+  const picked = new Set(await prompter.multiSelect("Extras", choices.map((choice) => ({
+    value: choice.value,
+    label: choice.label,
+    enabled: extras[choice.value]
+  }))));
+  const next = { ...extras };
+  for (const choice of choices) {
+    next[choice.value] = picked.has(choice.value);
+  }
+  for (const choice of EXTRA_CHOICES) {
+    if (!extraApplies(choice.value, layers.auth) && flags.extras[choice.value] === undefined) {
+      next[choice.value] = false;
+    }
+  }
+  return next;
+}
 async function promptLayers(flags, prompter) {
   const layers = applyFlagOverrides(defaultLayers(), flags);
   layers.frontend = await prompter.select("Frontend", [
@@ -572,16 +1017,10 @@ async function promptLayers(flags, prompter) {
     { value: "log", label: "log: print messages" },
     { value: "smtp", label: "smtp" }
   ], layers.mail);
-  if (layers.frontend === "spa-react" || layers.frontend === "hybrid") {
+  if (flags.spaPrefix === undefined && (layers.frontend === "spa-react" || layers.frontend === "hybrid")) {
     layers.spaPrefix = await prompter.question("SPA prefix", layers.spaPrefix);
   }
-  const askExtras = flags.extrasPrompt || await prompter.confirm("Configure extras (MFA, SCIM, metrics)?", false);
-  if (askExtras) {
-    layers.extras.mfa = await prompter.confirm("Authenticator MFA (cookie challenge + setup pages)?", layers.extras.mfa);
-    layers.extras.emailVerification = await prompter.confirm("Email verification (signed links + /email/verify)?", layers.extras.emailVerification);
-    layers.extras.scim = await prompter.confirm("SCIM /Users adapter?", layers.extras.scim);
-    layers.extras.metrics = await prompter.confirm("Metrics token?", layers.extras.metrics);
-  }
+  layers.extras = await promptExtras(prompter, layers.extras, layers, flags);
   if (!dockerFlagsProvided(flags)) {
     layers.docker = await promptDockerLayer(prompter, layers);
   }
@@ -608,7 +1047,14 @@ async function promptDockerLayer(prompter, layers) {
   for (const name of needed) {
     services[name] = await prompter.confirm(`Docker Compose for ${DOCKER_SERVICE_LABELS[name]}?`, true);
   }
+  const databaseService = dockerDatabaseService(layers.database);
+  if (databaseService && services[databaseService]) {
+    services.adminer = await prompter.confirm(`Docker Compose for ${DOCKER_SERVICE_LABELS.adminer}?`, true);
+  }
   const selected = needed.filter((name) => services[name]);
+  if (services.adminer) {
+    selected.push("adminer");
+  }
   return {
     enabled: selected.length > 0,
     services
@@ -1910,6 +2356,17 @@ function renderDockerCompose(projectName, layers) {
     volumes:
       - mysqldata:/var/lib/mysql`);
   }
+  if (selectedSet.has("adminer")) {
+    const server = selectedSet.has("mysql") ? "mysql" : "postgres";
+    services.push(`  adminer:
+    image: adminer:5.4.2
+    environment:
+      ADMINER_DEFAULT_SERVER: ${server}
+    depends_on:
+      - ${server}
+    ports:
+      - "8080:8080"`);
+  }
   if (selectedSet.has("redis")) {
     services.push(`  redis:
     image: redis:7-alpine
@@ -2030,6 +2487,14 @@ function renderSupportingToolsReadme(layers) {
   if (dockerOn.length > 0) {
     const names = dockerOn.map((name) => DOCKER_SERVICE_LABELS[name]).join(", ");
     lines.push(`Docker Compose includes ${names}.`, "", "```bash", "docker compose up -d", "```", "");
+    if (dockerSet.has("adminer")) {
+      const mysql = layers.database === "mysql";
+      const system = mysql ? "MySQL" : "PostgreSQL";
+      const server = mysql ? "mysql" : "postgres";
+      const username = mysql ? "root" : "postgres";
+      const password = mysql ? "root" : "postgres";
+      lines.push(`Adminer: http://localhost:8080 (${system}, server \`${server}\`, username \`${username}\`, password \`${password}\`).`, "");
+    }
   }
   if (localOn.length > 0) {
     const names = localOn.map((name) => DOCKER_SERVICE_LABELS[name]).join(", ");
@@ -2102,6 +2567,8 @@ Cookie name is \`strata_session\`. Forms send CSRF as \`_token\`.
 Opaque token login: \`POST /api/v1/auth/login\` with \`{ "email", "password" }\`. Register: \`POST /api/v1/auth/register\`. Forgot/reset: \`POST /api/v1/auth/forgot-password\` and signed \`POST /api/v1/auth/reset-password\`. Send \`Authorization: Bearer\` after login.
 ` : ""}${authUsesJwt(layers.auth) ? `
 JWT mint: \`POST /api/auth/token\` with email and password. Short-lived. Not a portal session.
+` : ""}${layers.extras.metrics ? `
+Prometheus scrape: \`GET /metrics\`. Production requires \`Authorization: Bearer <METRICS_TOKEN>\`.
 ` : ""}
 ## Production
 
@@ -2781,6 +3248,10 @@ export { starterProviders };
 function renderCreateAppTs(layers) {
   const ensureLine = needsEnsure(layers) ? `import { ensureAppDatabase } from "./ensureDatabase.ts";
 ` : "";
+  const metricsImport = layers.extras.metrics ? `import { createMetricsRoutes } from "@getstrata/bootstrap/metricsRoutes";
+` : "";
+  const metricsSpread = layers.extras.metrics ? `
+    ...createMetricsRoutes(),` : "";
   return `import { join } from "node:path";
 import "./preload.ts";
 import { runProviderPhase } from "@getstrata/bootstrap/context";
@@ -2800,8 +3271,7 @@ import {
   ensureModulesLoaded,
 } from "@getstrata/bootstrap/discoverModules";
 import { createHealthRoutes } from "@getstrata/bootstrap/health";
-import { createMetricsRoutes } from "@getstrata/bootstrap/metricsRoutes";
-import { assertProductionSecrets } from "@getstrata/bootstrap/secretsGuard";
+${metricsImport}import { assertProductionSecrets } from "@getstrata/bootstrap/secretsGuard";
 import { createWebServer } from "@getstrata/bootstrap/web/server";
 import { setActiveApplicationContext } from "@getstrata/core/runtime/applicationRegistry";
 import { migrate } from "../db/migrate.ts";
@@ -2881,8 +3351,7 @@ ${needsEnsure(layers) ? `  await ensureAppDatabase();
 
   const routes = mergeSpaRoutes(context.dependencies, {
     ...createHealthRoutes(context.dependencies),
-    ...buildRoutes(context.dependencies),
-    ...createMetricsRoutes(),
+    ...buildRoutes(context.dependencies),${metricsSpread}
   }, {
     distDirectory: join(import.meta.dir, "../../frontend/dist"),
   });
@@ -3404,7 +3873,7 @@ function printNextSteps(projectName, layers, compose) {
   const dockerOn = selectedDockerServices(layers);
   const neededTools = neededDockerServices(layers);
   const localOn = neededTools.filter((name) => !dockerOn.includes(name));
-  const dockerSummary = neededTools.length === 0 ? "none" : dockerOn.length > 0 ? dockerOn.join("+") : "local";
+  const dockerSummary = dockerOn.length > 0 ? dockerOn.join("+") : neededTools.length === 0 ? "none" : "local";
   console.log(`
 Created Strata app in ${projectName}/
 `);
@@ -3416,6 +3885,9 @@ Next steps:`);
   if (compose) {
     console.log("  docker compose up -d");
   }
+  if (dockerOn.includes("adminer")) {
+    console.log("  Adminer: http://localhost:8080");
+  }
   if (localOn.length > 0) {
     console.log(`  Point env at local ${localOn.join(", ")} (see README).`);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getstrata/starter",
-  "version": "0.1.10",
+  "version": "0.1.12",
   "description": "Interactive create-strata wizard. Choose each layer; one database engine.",
   "type": "module",
   "license": "MIT",