@tulipes/cli 0.2.0-rc.2 → 0.3.0-rc.2

package/templates/app/modules/core/helpers/cache/index.ts

@@ -1,5 +1,5 @@
 import { Redis } from "ioredis";
-import type { Environment } from "@tulipes/core/env";
+import type { Ctx } from "@tulipes/core/boot";
 
 import { MemoryCache } from "./memory-cache.ts";
 import { RedisCache } from "./redis-cache.ts";
@@ -13,18 +13,19 @@ export { RedisCache } from "./redis-cache.ts";
 let active: { cache: Cache; redis?: Redis } | undefined;
 
 /**
- * The app's one cache, picked from the environment: redis when REDIS_URL is
- * declared, in-process memory otherwise (tests, minimal setups). Lazily
- * created, process-wide singleton.
+ * The app's one cache, picked from the core module's environment values:
+ * redis when `config.core.redisUrl` is set, in-process memory otherwise
+ * (tests, minimal setups). Lazily created, process-wide singleton.
  */
-export function appCache(environment: Environment): Cache {
+export function appCache({ config }: Pick<Ctx, "config">): Cache {
   if (active) return active.cache;
 
-  if (environment.store.has("REDIS_URL")) {
+  const redisUrl = config.core?.redisUrl;
+  if (redisUrl) {
     // Fail a command fast instead of queueing it and retrying for seconds: the
     // cache is consulted on every request, so a redis outage must cost a miss,
     // not a stalled request. RedisCache turns the rejection into that miss.
-    const redis = new Redis(String(environment.get("REDIS_URL")), {
+    const redis = new Redis(redisUrl, {
       maxRetriesPerRequest: 1,
       enableOfflineQueue: false,
     });

package/templates/app/modules/core/helpers/lazy.ts

@@ -3,9 +3,9 @@ import type { RequestHandler } from "express";
 /**
  * Middleware built on its first request rather than while the routes
  * file runs. Inspection (`tulipes routes`, `tulipes spec`) builds every
- * router without resolving the environment or acquiring a service, so a
- * middleware that reads a variable or opens a client is built here, once,
- * when a real request arrives.
+ * router without acquiring a service, and an environment value read while
+ * building throws there — so a middleware that reads one or opens a client
+ * is built here, once, when a real request arrives.
  */
 export function lazy(build: () => RequestHandler): RequestHandler {
   let handler: RequestHandler | undefined;

package/templates/app/modules/core/helpers/logger/index.ts

@@ -3,8 +3,8 @@ import { join } from "node:path";
 // namespace that only the default export carries.
 import pino from "pino";
 import type { Logger, TransportTargetOptions } from "pino";
-import type { ProcessMode } from "@tulipes/core/boot";
-import type { Environment } from "@tulipes/core/env";
+import type { Ctx } from "@tulipes/core/boot";
+import { toZonedISO } from "@tulipes/core/time";
 
 /**
  * The app's logger, shared by every module.
@@ -24,7 +24,7 @@ let instance: Logger | undefined;
 
 /**
  * How the files are named and rotated. These never needed to differ per
- * deployment, so they are constants rather than environment variables;
+ * deployment, so they are constants rather than environment values;
  * the settings module's log stream reads the same names.
  */
 export const LOG_FILES = Object.freeze({
@@ -40,13 +40,16 @@ export const LOG_FILES = Object.freeze({
   retentionFiles: 14,
 });
 
-export function logger(environment: Environment, mode: ProcessMode = "backend"): Logger {
+export function logger({ config, mode }: Pick<Ctx, "config" | "mode">): Logger {
   if (instance) return instance;
 
-  const level = String(environment.get("LOG_LEVEL"));
+  // The destinations are the core module's environment values, bound at
+  // boot from LOG_LEVEL, LOG_CONSOLE, LOG_FILE and LOG_DIR — each with a
+  // default, so they are there whenever the app runs.
+  const { logLevel: level, logConsole, logFile, logDir } = config.core!;
   const targets: TransportTargetOptions[] = [];
 
-  if (Boolean(environment.get("LOG_CONSOLE"))) {
+  if (logConsole) {
     targets.push({
       target: "pino-pretty",
       level,
@@ -61,8 +64,8 @@ export function logger(environment: Environment, mode: ProcessMode = "backend"):
     });
   }
 
-  if (Boolean(environment.get("LOG_FILE"))) {
-    const dir = String(environment.get("LOG_DIR"));
+  if (logFile) {
+    const dir = logDir;
     const rotation = {
       // Both limits apply: whichever trips first rotates the file.
       frequency: LOG_FILES.rotationFrequency,
@@ -92,11 +95,20 @@ export function logger(environment: Environment, mode: ProcessMode = "backend"):
     });
   }
 
+  // Every line's time is written in the process zone with its offset —
+  // "2026-10-13T15:00:00.000+01:00" — so a file reads in the app's local
+  // time and still sorts and parses as one exact instant. Core moves the
+  // process onto config.timezone.default before bootstrap creates this
+  // logger, which is also what the console's SYS: times and the daily
+  // rotation above follow.
+  const zone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+  const options = { level, base: { mode }, timestamp: () => `,"time":"${toZonedISO(Date.now(), zone)}"` };
+
   instance = targets.length
-    ? pino({ level, base: { mode } }, pino.transport({ targets }))
+    ? pino(options, pino.transport({ targets }))
     : // Every destination disabled: still return a working logger rather
       // than null-checking at a hundred call sites.
-      pino({ level, base: { mode } });
+      pino(options);
 
   return instance;
 }
@@ -106,10 +118,6 @@ export function logger(environment: Environment, mode: ProcessMode = "backend"):
  * visible in both destinations: `[users] ready` on the console, and a
  * queryable `"module":"users"` field in the file.
  */
-export function moduleLogger(
-  environment: Environment,
-  name: string,
-  mode: ProcessMode = "backend",
-): Logger {
-  return logger(environment, mode).child({ module: name });
+export function moduleLogger(ctx: Pick<Ctx, "config" | "mode">, name: string): Logger {
+  return logger(ctx).child({ module: name });
 }

package/templates/app/modules/core/module.config.ts

@@ -12,9 +12,11 @@ import { registerBasePlugins } from "./helpers/mongoose/index.ts";
 registerBasePlugins();
 
 /**
- * The sys core module's own settings. The environment keeps only what boot
- * needs before the store answers (the port, the connection strings, the log
- * destinations) and the secrets; everything else is a setting like this one.
+ * The sys core module's own settings. Its environment values (package.json
+ * `tulipes.env`) keep only what boot needs before the store answers — the
+ * port, the connection strings, the log destinations — and the secrets, and
+ * land beside these as `config.core.port`, `config.core.redisUrl`…;
+ * everything else is a setting like this one.
  */
 export default defineConfig({
   schema: z.object({

package/templates/app/modules/core/package.json

@@ -6,30 +6,57 @@
   "tulipes": {
     "tier": "sys",
     "priority": 0,
-    "env": [
-      {
-        "name": "PORT",
+    "env": {
+      "port": {
+        "key": "PORT",
         "type": "number",
         "group": "http",
         "description": "HTTP port the backend process listens on",
         "default": 3000
       },
-      {
-        "name": "MONGO_URI",
+      "mongodbUri": {
+        "key": "MONGO_URI",
         "type": "url",
         "group": "database",
-        "required": true,
-        "description": "MongoDB connection string"
+        "description": "Full MongoDB connection string; when set it wins over the parts below (the only way to name a replica set, an Atlas mongodb+srv:// cluster or driver options)"
+      },
+      "mongodbHost": {
+        "key": "MONGO_HOST",
+        "type": "url",
+        "group": "database",
+        "description": "MongoDB host as a URI without credentials or database: mongodb://host:port",
+        "default": "mongodb://localhost:27017"
+      },
+      "mongodbUsername": {
+        "key": "MONGO_USERNAME",
+        "type": "string",
+        "group": "database",
+        "description": "MongoDB username; empty for an unauthenticated server",
+        "default": ""
+      },
+      "mongodbPassword": {
+        "key": "MONGO_PASSWORD",
+        "type": "secret",
+        "group": "database",
+        "description": "MongoDB password",
+        "default": ""
+      },
+      "mongodbDbName": {
+        "key": "MONGO_DBNAME",
+        "type": "string",
+        "group": "database",
+        "description": "MongoDB database name",
+        "default": "tulipes_example"
       },
-      {
-        "name": "REDIS_URL",
+      "redisUrl": {
+        "key": "REDIS_URL",
         "type": "url",
         "group": "redis",
         "required": true,
-        "description": "Redis connection string (queues, cache)"
+        "description": "Redis connection string (queues, cache, rate limits)"
       },
-      {
-        "name": "LOG_LEVEL",
+      "logLevel": {
+        "key": "LOG_LEVEL",
         "type": "enum",
         "enum": [
           "fatal",
@@ -43,28 +70,28 @@
         "description": "Lowest level that reaches any destination",
         "default": "info"
       },
-      {
-        "name": "LOG_CONSOLE",
+      "logConsole": {
+        "key": "LOG_CONSOLE",
         "type": "boolean",
         "group": "logging",
         "description": "Pretty coloured logs on stdout; turn off where a collector reads files only",
         "default": true
       },
-      {
-        "name": "LOG_FILE",
+      "logFile": {
+        "key": "LOG_FILE",
         "type": "boolean",
         "group": "logging",
         "description": "Write JSON-line log files under LOG_DIR",
         "default": true
       },
-      {
-        "name": "LOG_DIR",
+      "logDir": {
+        "key": "LOG_DIR",
         "type": "string",
         "group": "logging",
         "description": "Directory for log files, relative to the app root or absolute",
         "default": "logs"
       }
-    ]
+    }
   },
   "dependencies": {
     "@tulipes/core": "workspace:*",

package/templates/app/modules/core/routes/core.routes.ts

@@ -9,11 +9,11 @@ import { lazy } from "../helpers/lazy.ts";
  * The sys core module loads first, so what it mounts on `ctx.app` runs on
  * every request of every later module: this is the global middleware slot.
  */
-export default function coreRoutes({ app, Environment }: BackendCtx): void {
+export default function coreRoutes(ctx: BackendCtx): void {
   // The cache client opens on first use; built on the first request so
-  // inspection never touches Redis.
-  app.use(lazy(() => {
-    const cache = appCache(Environment);
+  // inspection never touches Redis, nor reads the URL it would need.
+  ctx.app.use(lazy(() => {
+    const cache = appCache(ctx);
     return (async (_req, res, next) => {
       res.setHeader("X-Request-Id", randomUUID());
       const served = await cache.wrap("stats:served-sample", 10, async () => Date.now());

package/templates/app/modules/hello/agent/hello.agent.ts

@@ -2,26 +2,30 @@ import { action, defineAgent } from "@tulipes/core/agent";
 import { requireModels } from "@tulipes/core/boot";
 import { z } from "zod/v4";
 
+import { findGreetings } from "../helpers/greetings.ts";
+
 /**
- * What an agent sees of this module. Every route is a tool already — its
- * rai() gives the name, description, input schema and permission — so this
- * file adds what cannot be derived: the summary, which routes to expose,
- * and an action that is not an endpoint. A module without this file
- * exposes every route; `pnpm tulipes agent manifest` prints the result.
+ * What this module offers to agents — an in-app agent module reads it from
+ * `ctx.agent.manifest()`, Claude Code through `tulipes-mcp`. Routes are the
+ * API and are never tools: an action is declared here, with its own id (a
+ * permission granted in module.acl.ts), input schema and handler, and
+ * shares its logic with the routes through helpers/. `pnpm tulipes agent
+ * manifest` prints the result.
  */
 export default defineAgent({
   summary: "Greets callers and counts how often each greeting is used.",
-  tools: [
-    { route: "hello:greet", description: "A greeting in the caller's language" },
-    { route: "hello:greet-name" },
-    { route: "hello:list-greetings", description: "The stored greetings, with how often each was used" },
-    { route: "hello:use-greeting" },
+  actions: [
+    action({
+      id: "hello:web:greetings",
+      description: "The stored greetings, with how often each was used",
+      readOnly: true,
+      handler: async (ctx) => (await findGreetings(ctx))[0],
+    }),
 
-    // An action: the id is a permission like any route's, granted to
-    // admin through hello:* in the auth module's ACL. The ACL decides,
-    // then the schema validates, then this runs.
+    // The ACL decides on the id (admin holds hello:* in the auth module's
+    // ACL), then the schema validates, then this runs.
     action({
-      id: "hello:reset-counts",
+      id: "hello:bo:greetings:reset",
       description: "Reset the usage counter of every greeting to zero",
       input: z.object({ confirm: z.literal(true).describe("Set to true to confirm the reset") }),
       handler: async (ctx) => {

package/templates/app/modules/hello/controllers/{hello.controllers.ts → web/hello.controllers.ts}

@@ -1,7 +1,7 @@
 import type { Request, RequestHandler, Response } from "express";
 import type { Ctx } from "@tulipes/core/boot";
 
-import { buildGreeting } from "../helpers/greeting.ts";
+import { buildGreeting } from "../../helpers/greeting.ts";
 
 /**
  * Controllers hold the work so routes stay a table of contents. The

package/templates/app/modules/hello/controllers/{greetings.controllers.ts → web/hello.greetings.controllers.ts}

@@ -2,7 +2,9 @@ import type { Request, RequestHandler, Response } from "express";
 import { requireModels, requireQueues, type Ctx } from "@tulipes/core/boot";
 import { HttpError } from "@tulipes/core/http";
 
-export class GreetingsController {
+import { findGreetings } from "../../helpers/greetings.ts";
+
+export class HelloGreetingsController {
   readonly #ctx: Ctx;
 
   constructor(ctx: Ctx) {
@@ -14,13 +16,7 @@ export class GreetingsController {
       // ?page and ?per_page, already clamped by config.pagination — so
       // every list endpoint in every module paginates the same way.
       const { per_page, skip } = req.page;
-      const Greeting = requireModels(this.#ctx).get("Greeting");
-
-      const [greetings, total_items] = await Promise.all([
-        Greeting.find().select("name message times_used -_id")
-          .skip(skip).limit(per_page).lean(),
-        Greeting.countDocuments(),
-      ]);
+      const [greetings, total_items] = await findGreetings(this.#ctx, { skip, limit: per_page });
 
       // Passing total_items is what marks this a page: respond fills in
       // page, per_page and total_pages from the request and the count.

package/templates/app/modules/hello/helpers/greetings.ts

@@ -0,0 +1,14 @@
+import { requireModels, type Ctx } from "@tulipes/core/boot";
+
+/**
+ * One query, two callers: the list route pages it, the agent action reads
+ * the first page. Logic a route and an action share lives here, so neither
+ * calls the other.
+ */
+export function findGreetings(ctx: Ctx, { skip = 0, limit = 20 } = {}) {
+  const Greeting = requireModels(ctx).get("Greeting");
+  return Promise.all([
+    Greeting.find().select("name message times_used -_id").skip(skip).limit(limit).lean(),
+    Greeting.countDocuments(),
+  ]);
+}

package/templates/app/modules/hello/module.acl.ts

@@ -1,16 +1,21 @@
 import type { AclBuilder } from "@tulipes/core/acl";
 
 /**
- * Roles are global and defined once by the sys core module; a feature
- * module only attaches grants, and always on resources namespaced by
- * its own name ("hello:*"). Granting the same role+resource from two
- * modules crashes the boot.
+ * Roles are global and defined once by the auth module; a feature module
+ * only attaches grants, and always on its own RAIs ("hello:…"). Granting
+ * the same role+resource from two modules crashes the boot.
+ *
+ * A grant ending in `:*` covers everything under it, the bare resource
+ * included: `hello:web:greet:*` reaches `hello:web:greet` and
+ * `hello:web:greet:by-name`.
  */
 export default function helloAcl(acl: AclBuilder): void {
   // Public: the greeting endpoints are granted to guest, which is
   // how an endpoint is made public — there is no "skip auth" flag.
-  acl.allow("guest", "hello:greet", "hello:greet-name", "hello:demo-missing");
+  acl.allow("guest", "hello:web:greet:*", "hello:web:demo:*");
 
-  // Signed in: the secret needs a real role.
-  acl.allow("user", "hello:read", "hello:list-greetings", "hello:use-greeting");
+  // Signed in: the secret, and listing and using greetings. The reset
+  // action is `hello:bo:greetings:reset`, which only admin's `hello:*`
+  // reaches.
+  acl.allow("user", "hello:web:secret", "hello:web:greetings:*");
 }

package/templates/app/modules/hello/queues/hello.queues.ts

@@ -25,7 +25,7 @@ export default function helloQueues(ctx: Ctx, queues: QueueRegistry): void {
   const { models } = ctx;
   // The same logger the backend uses. In the worker process it writes
   // to app-worker.log, so the two processes never share a file.
-  const log = moduleLogger(ctx.Environment, "hello", ctx.mode);
+  const log = moduleLogger(ctx, "hello");
 
   queues.process("hello.count-greeting", async (job) => {
     // Jobs retry, so processors must be idempotent-safe. Pass ids in

package/templates/app/modules/hello/routes/{greetings.routes.ts → web/hello.greetings.routes.ts}

@@ -1,21 +1,21 @@
 import { Router } from "express";
 import type { BackendCtx } from "@tulipes/core/boot";
 
-import { GreetingsController } from "../controllers/greetings.controllers.ts";
+import { HelloGreetingsController } from "../../controllers/web/hello.greetings.controllers.ts";
 
 export default function greetingsRoutes(ctx: BackendCtx): Router {
   const { rai } = ctx;
   const router = Router();
-  const greetings = new GreetingsController(ctx);
+  const greetings = new HelloGreetingsController(ctx);
 
   router.get("/greetings", rai({
-      id: "hello:list-greetings",
+      id: "hello:web:greetings",
       name: "List greetings",
       description: "Reads the seeded rows, clamped by the shared bounds",
     }), greetings.list());
 
   router.post("/greetings/:name/use", rai({
-      id: "hello:use-greeting",
+      id: "hello:web:greetings:use",
       status: 202,
       name: "Use a greeting",
       description: "Queues a job that counts the use",

package/templates/app/modules/hello/routes/{hello.routes.ts → web/hello.routes.ts}

@@ -2,14 +2,20 @@ import { Router } from "express";
 import type { BackendCtx } from "@tulipes/core/boot";
 import { HttpError } from "@tulipes/core/http";
 
-import { HelloController } from "../controllers/hello.controllers.ts";
+import { HelloController } from "../../controllers/web/hello.controllers.ts";
 
 /**
+ * This module has two routes files for one scope, so they sit in a folder
+ * named after it: routes/web/hello.routes.ts and
+ * routes/web/hello.greetings.routes.ts. One file per scope would instead be
+ * named scope-first at the top of routes/ (web.hello.routes.ts), as the
+ * users module does. Neither is enforced; core reads every *.routes.ts.
+ *
  * A routes file is a plain function of the context. It returns a Router,
  * which core mounts under `config.api.prefix`, and declares a RAI on every
  * endpoint: the id is the permission, and a route without one refuses the
- * boot. Build the router from the context; read models, settings and the
- * environment inside handlers, where they are live.
+ * boot. Build the router from the context; read models and config inside
+ * handlers, where they are live.
  */
 export default function helloRoutes(ctx: BackendCtx): Router {
   const { rai } = ctx;
@@ -17,24 +23,24 @@ export default function helloRoutes(ctx: BackendCtx): Router {
   const hello = new HelloController(ctx);
 
   router.get("/hello", rai({
-      id: "hello:greet",
+      id: "hello:web:greet",
       name: "Greet",
       description: "Public greeting, granted to guest",
     }), hello.greet());
 
   router.get("/hello/secret", rai({
-      id: "hello:read",
+      id: "hello:web:secret",
       name: "Read the secret",
-      description: "Requires a role granted hello:read",
+      description: "Requires a role granted hello:web:secret",
     }), hello.secret());
 
   router.get("/hello/:name", rai({
-      id: "hello:greet-name",
+      id: "hello:web:greet:by-name",
       name: "Greet by name",
     }), hello.byName());
 
   router.get("/hello/demo/missing", rai({
-      id: "hello:demo-missing",
+      id: "hello:web:demo:missing",
       name: "HttpError demo",
     }), async () => {
       throw new HttpError(404, "nothing here", { details: { hint: "demo endpoint" } });

package/templates/app/modules/security/helpers/rate-limit.ts

@@ -62,8 +62,9 @@ export function rebuildRateLimits(ctx: Ctx, settings: RateLimitSettings): { limi
   const next = {
     settings: { ...settings },
     limits: createRateLimits({
-      redisUrl: String(ctx.Environment.get("REDIS_URL")),
-      namespace: settings.namespace + ":" + ctx.Environment.appEnv,
+      // The core module's environment value; the app refuses to boot without it.
+      redisUrl: ctx.config.core!.redisUrl,
+      namespace: settings.namespace + ":" + ctx.appEnv,
       windowMs: settings.windowMs,
       authLimit: settings.auth,
       sessionLimit: settings.session,

package/templates/app/modules/security/routes/security.routes.ts

@@ -15,11 +15,11 @@ import { configuredRateLimits } from "../helpers/rate-limit.ts";
  * current values (cheap, and a write lands at once), the proxy policy is
  * set here and again by module.config's onChange, and the rate limiter is
  * rebuilt there, so the handlers below always delegate to the current set.
- * The logger reads the environment, which inspection does not resolve, so
- * it is built on its first request.
+ * The logger reads the core module's environment values, which inspection
+ * refuses, so it is built on its first request.
  */
 export default function securityRoutes(ctx: BackendCtx): void {
-  const { app, Environment, mode, config } = ctx;
+  const { app, config } = ctx;
   const prefix = String(config.api?.prefix ?? "");
   const security = () => config.security!;
 
@@ -27,7 +27,7 @@ export default function securityRoutes(ctx: BackendCtx): void {
   app.use((req, res, next) => helmet(helmetOptions(security()))(req, res, next));
   app.use((req, res, next) => cors(corsOptions(security()))(req, res, next));
   app.use(lazy(() => pinoHttp({
-    logger: logger(Environment, mode),
+    logger: logger(ctx),
     customLogLevel: (_req, res, err) =>
       err || res.statusCode >= 500 ? "error" : res.statusCode >= 400 ? "warn" : "info",
     genReqId: (_req, res) => String(res.getHeader("X-Request-Id") ?? ""),

package/templates/app/modules/settings/bootstrap/log-streams.bootstrap.ts

@@ -7,6 +7,6 @@ import { configuredLogStreams } from "../helpers/log-stream.ts";
  * aborts the moment shutdown begins, before HTTP stops accepting, so the
  * streams end while the server is still draining ordinary requests.
  */
-export default function logStreams({ Environment, signal }: RuntimeCtx): void {
-  signal.addEventListener("abort", () => configuredLogStreams(Environment).drain(), { once: true });
+export default function logStreams(ctx: RuntimeCtx): void {
+  ctx.signal.addEventListener("abort", () => configuredLogStreams(ctx).drain(), { once: true });
 }

package/templates/app/modules/settings/controllers/{settings.controllers.ts → bo.settings.controllers.ts}

@@ -13,19 +13,20 @@ import { configuredLogStreams, type LogStreams } from "../helpers/log-stream.ts"
  * while the stream is open, since a stream outlives the request that
  * opened it.
  */
-export class SettingsController {
+export class BoSettingsController {
   readonly #logStreams: LogStreams;
   readonly #ctx: Ctx;
 
   constructor(ctx: Ctx) {
-
     this.#ctx = ctx;
-    this.#logStreams = configuredLogStreams(ctx.Environment);
+    this.#logStreams = configuredLogStreams(ctx);
   }
 
   logStream(): RequestHandler {
     return async (req: Request, res: Response) => {
-      if (!Boolean(this.#ctx.Environment.get("LOG_FILE"))) {
+      // Where the core module's logger writes, from its environment values.
+      const { logFile, logDir } = this.#ctx.config.core!;
+      if (!logFile) {
         throw new HttpError(409, "fileLoggingDisabled", {
           code: "FILE_LOGGING_DISABLED",
           defaultMessage: "LOG_FILE is off — there are no log files to stream",
@@ -39,7 +40,7 @@ export class SettingsController {
 
       const session = req.auth.session;
       await this.#logStreams.open(res, {
-        authorize: createAccessCheck(this.#ctx, req.auth, "settings:logs"),
+        authorize: createAccessCheck(this.#ctx, req.auth, "settings:bo:logs"),
         userId: req.auth.user ? String(req.auth.user._id) : "",
         expiresAt: session
           ? Math.min(
@@ -47,7 +48,7 @@ export class SettingsController {
               session.expires_at.getTime(),
             )
           : 0,
-        dir: String(this.#ctx.Environment.get("LOG_DIR")),
+        dir: logDir,
         prefix: `${LOG_FILES.basename}-${which}`,
         process: which,
         tail,

package/templates/app/modules/settings/helpers/log-stream.ts

@@ -1,5 +1,5 @@
 import type { Response } from "express";
-import type { Environment } from "@tulipes/core/env";
+import type { Ctx } from "@tulipes/core/boot";
 import { HttpError } from "@tulipes/core/http";
 import { AccessLease } from "./access-lease.ts";
 import { tailLogs, type Tail } from "./log-tail.ts";
@@ -37,14 +37,15 @@ const LEVELS: Record<string, number> = {
   fatal: 60,
 };
 
-const instances = new WeakMap<Environment, LogStreams>();
+/** One manager per boot: the context object is what a boot has exactly one of. */
+const instances = new WeakMap<Ctx, LogStreams>();
 
 /** Keep the stopped instance until the boot is collected; late requests cannot reopen it. */
-export function configuredLogStreams(environment: Environment): LogStreams {
-  let streams = instances.get(environment);
+export function configuredLogStreams(ctx: Ctx): LogStreams {
+  let streams = instances.get(ctx);
   if (!streams) {
     streams = new LogStreams();
-    instances.set(environment, streams);
+    instances.set(ctx, streams);
   }
   return streams;
 }

package/templates/app/modules/settings/routes/{settings.routes.ts → bo.settings.routes.ts}

@@ -1,7 +1,7 @@
 import { Router } from "express";
 import type { BackendCtx } from "@tulipes/core/boot";
 
-import { SettingsController } from "../controllers/settings.controllers.ts";
+import { BoSettingsController } from "../controllers/bo.settings.controllers.ts";
 import { logQuery } from "../schemas/settings.schemas.ts";
 
 /**
@@ -13,18 +13,17 @@ import { logQuery } from "../schemas/settings.schemas.ts";
 export default function settingsRoutes(ctx: BackendCtx): void {
   const { rai, routes, config } = ctx;
   const router = Router();
-  const settings = new SettingsController(ctx);
+  const settings = new BoSettingsController(ctx);
 
   router.get(
     "/logs/stream",
     rai({
-      id: "settings:logs",
+      id: "settings:bo:logs",
       name: "Stream logs",
       description: "Server-Sent Events over the log files — backend or worker",
       folder: "settings",
       query: logQuery,
       // A stream is not a tool: it never ends on its own.
-      agent: false,
     }),
     settings.logStream(),
   );