@mcp-rune/create 0.11.0 → 0.11.1

package/README.md

@@ -147,6 +147,12 @@ These change the run itself — they don't answer a question, so they only appea
 | `--offline-template <path>` | Use a local template directory instead of fetching via `tiged`. |
 | `--mcp-rune-local <path>` | Point the scaffolded project at a local `mcp-rune` checkout (also reads `MCP_RUNE_LOCAL_PATH`). |
 
+## Logging in generated projects
+
+Generated projects log via the framework logger (or Pino with `--logger pino`). Log behavior is controlled by env vars — `LOG_LEVEL` (`error|warn|info|debug`), `LOG_FORMAT` (`text|json`), `LOG_FILE_FORMAT`, `LOG_FILE_ENABLED`, and `NODE_ENV` (production forces JSON). `LOG_LEVEL=debug rune-app` works out of the box, since the logger honors these at startup.
+
+The **advanced** preset goes further: its `config/schema.js` spreads mcp-rune's `frameworkConfigSchema`, so those vars are validated by `loadConfig` and applied to the logger via `configureLogging()` in `src/config.ts` — one source of truth, no stray `process.env` reads. The **simple** preset relies on the logger's bootstrap defaults. See each preset's `.env.example`.
+
 ## Templates
 
 As an alternative to presets, scaffold from a runnable example in the [`mcp-rune/examples`](https://github.com/mcp-rune/examples) repo:

package/dist/commands/add-model.js

@@ -118,7 +118,7 @@ function makeVars(cwd, preset, models) {
         useLangfuse: false,
         toolClasses: [],
         promptStrategies: {},
-        mcpRuneVersion: pkg.dependencies?.['@mcp-rune/mcp-rune'] ?? '^0.102.0',
+        mcpRuneVersion: pkg.dependencies?.['@mcp-rune/mcp-rune'] ?? '^0.105.1',
         nodeEngine: '>=24.0.0',
     };
 }

package/dist/render/copy-tree.js

@@ -128,7 +128,7 @@ function makeVars(answers) {
         toolClasses: answers.toolClasses ?? [],
         promptStrategies: answers.promptStrategies ?? {},
         models: normalizeModels(answers.models),
-        mcpRuneVersion: answers.mcpRuneVersion ?? '^0.102.0',
+        mcpRuneVersion: answers.mcpRuneVersion ?? '^0.105.1',
         nodeEngine: answers.nodeEngine ?? '>=24.0.0',
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mcp-rune/create",
-  "version": "0.11.0",
+  "version": "0.11.1",
   "description": "Scaffolder for mcp-rune-based MCP servers",
   "type": "module",
   "bin": {

package/templates/advanced/.env.example.ejs

@@ -80,3 +80,14 @@ LANGFUSE_SECRET_KEY=
 # LANGFUSE_PUBLIC_KEY=
 # LANGFUSE_SECRET_KEY=
 <% } -%>
+
+# =============================================================================
+# Logging (optional)
+# =============================================================================
+# Declared via frameworkConfigSchema (spread into config/schema.js) and applied
+# by configureLogging() in src/config.ts, so these are validated config — not
+# loose env reads. LOG_LEVEL=debug also works ad-hoc when debugging.
+# LOG_LEVEL=info          # error | warn | info | debug
+# LOG_FORMAT=json         # text (default) | json; NODE_ENV=production forces json
+# LOG_FILE_FORMAT=json    # file format; inherits LOG_FORMAT if unset
+# LOG_FILE_ENABLED=false  # write rotating daily files under logs/

package/templates/advanced/__only_if_hasHttp__/src/servers/remote.ts.ejs

@@ -17,7 +17,7 @@ const { config, createOAuthService, mcpConfig } = await import('../config.js')
 
 const port = config.transport.remote.port
 const baseUrl = config.transport.remote.baseUrl ?? `http://localhost:${port}`
-const isProduction = config.http.environment === 'production'
+const isProduction = config.runtime.environment === 'production'
 
 const server = new HttpServer({
   port,

package/templates/advanced/__only_if_usePinoLogger__/src/observability/logger.ts

@@ -19,6 +19,10 @@ interface ChildLogger {
   child: (meta: Record<string, unknown>) => ChildLogger
 }
 
+// Bootstrap level honors LOG_LEVEL (the usual pino/12-factor convention) so
+// logging works before config is loaded. `configureLogging()` below lets the
+// validated config supersede it — keeping a single source of truth once
+// loadConfig has run.
 const base = pino({
   level: process.env.LOG_LEVEL ?? 'info',
   formatters: {
@@ -56,6 +60,14 @@ export const logger = {
   setApp(name: string): void {
     appName = name
   },
+  /**
+   * Apply validated logging config (from loadConfig), superseding the
+   * LOG_LEVEL bootstrap. Mirrors the framework logger's configureLogging so
+   * config.ts can wire both with one shape.
+   */
+  configureLogging(opts: { level?: string } = {}): void {
+    if (opts.level) base.level = opts.level
+  },
   child(meta: Record<string, unknown> = {}): ChildLogger {
     return buildChild(meta)
   }

package/templates/advanced/config/schema.ts.ejs

@@ -5,9 +5,14 @@
  * at startup. Every env var read in the codebase should be declared here.
  */
 
-import type { ConfigSchema } from '@mcp-rune/mcp-rune/core'
+import { frameworkConfigSchema, type ConfigSchema } from '@mcp-rune/mcp-rune/core'
 
 export const configSchema = {
+  // Framework-owned logging + runtime vars (logging.* → LOG_*,
+  // runtime.environment → NODE_ENV). Applied to the logger in config.ts via
+  // configureLogging() so the validated values supersede the env bootstrap.
+  ...frameworkConfigSchema,
+
   api: {
     url: {
       env: 'API_URL',
@@ -104,7 +109,7 @@ export const configSchema = {
 
   http: {
     corsOrigins: { env: 'CORS_ORIGINS', doc: 'Comma-separated list of allowed CORS origins' },
-    environment: { env: 'NODE_ENV', default: 'development', doc: 'Runtime environment' },
+    // NODE_ENV is provided by frameworkConfigSchema as runtime.environment.
   },
 
   errorTracking: {

package/templates/advanced/src/config.ts.ejs

@@ -12,11 +12,14 @@ import { createServer as createServerFactory } from '@mcp-rune/mcp-rune/server'
 import { _setAdapter, OAuthService, PostgresqlAdapter } from '@mcp-rune/mcp-rune/oauth2'
 <% } -%>
 <% if (usePinoLogger) { -%>
-import { errorTracking, tracing, vectorStorage } from '@mcp-rune/mcp-rune/runtime'
+// Your app logs via Pino (below), but mcp-rune's internals log via the
+// framework logger — configure it from the same validated config.
+import { errorTracking, logger as frameworkLogger, tracing, vectorStorage } from '@mcp-rune/mcp-rune/runtime'
 <% } else { -%>
 import { errorTracking, logger, tracing, vectorStorage } from '@mcp-rune/mcp-rune/runtime'
 <% } -%>
 import { createPgvectorAdapter } from '@mcp-rune/mcp-rune/runtime/vendor/pgvector'
+import { assertMigrationsCurrent, type Feature } from '@mcp-rune/mcp-rune/db/migrations'
 
 import { configSchema } from '../config/schema.js'
 import { closeDatabase, initDatabase } from './db.js'
@@ -67,7 +70,15 @@ interface AppConfig {
     }
 <% } -%>
   }
-  http: { corsOrigins: string | undefined; environment: string }
+  http: { corsOrigins: string | undefined }
+  // From frameworkConfigSchema (spread into configSchema):
+  logging: {
+    level: string
+    format?: 'text' | 'json'
+    fileFormat?: 'text' | 'json'
+    fileEnabled: boolean
+  }
+  runtime: { environment: string }
   errorTracking: { sentryDsn: string | undefined }
   tracing: { langfusePublicKey: string | undefined; langfuseSecretKey: string | undefined }
 }
@@ -88,10 +99,28 @@ const { name: SERVER_NAME, version: SERVER_VERSION } = startup.phase(
 export const config = startup.phase('config', 'Load configuration', (log) => {
   const cfg = loadConfig(configSchema)
   log.debug(cfg.toString())
-  return cfg as unknown as AppConfig & { toString(): string }
+  const appCfg = cfg as unknown as AppConfig & { toString(): string }
+  // Apply the validated logging config, superseding the framework logger's
+  // env-derived bootstrap. No process.env reads — the loaded config is the
+  // single source of truth.
+<% if (usePinoLogger) { -%>
+  // Framework internals log via the framework logger; your app logs via Pino.
+  // Configure both from the same validated config.
+  frameworkLogger.configureLogging({
+    ...appCfg.logging,
+    production: appCfg.runtime.environment === 'production',
+  })
+  logger.configureLogging({ level: appCfg.logging.level })
+<% } else { -%>
+  logger.configureLogging({
+    ...appCfg.logging,
+    production: appCfg.runtime.environment === 'production',
+  })
+<% } -%>
+  return appCfg
 })
 
-const isProduction = config.http.environment === 'production'
+const isProduction = config.runtime.environment === 'production'
 
 startup.phase('error-tracking', 'Error tracking', () => {
   // Vendor (Sentry) reads SENTRY_DSN + NODE_ENV from env directly; the
@@ -111,13 +140,22 @@ startup.phase('tracing', 'Tracing', () => {
   })
 })
 
-startup.phase('database', 'Database', (log) => {
+await startup.phaseAsync('database', 'Database', async (log) => {
   const pool = initDatabase(config.database.url)
   if (!pool) {
     log.debug('DATABASE_URL not set — database features disabled')
     return
   }
 
+  // Fail fast if the database is behind on migrations, instead of letting a
+  // missing column surface as a cryptic SQL error mid-tool-call. The feature
+  // set mirrors what this server provisions: always `core`, plus `analysis`
+  // when vector storage is enabled. Module-independent — covers every pending
+  // migration, not just analysis ones.
+  const features: Feature[] = ['core']
+  if (config.analysis.enabled) features.push('analysis')
+  await assertMigrationsCurrent(pool, { features })
+
 <% if (hasHttp && !useStaticTokenAuth) { -%>
   _setAdapter(new PostgresqlAdapter({ pool }))
   log.debug('OAuth token store connected')

package/templates/simple/.env.example

@@ -1,3 +1,8 @@
 # Token used by the framework's CRUD tools when calling your API backend.
 # For local dev without a real backend, any non-empty value works.
 ACCESS_TOKEN=demo-token
+
+# Logging — the framework logger honors these at bootstrap (the simple preset
+# doesn't use loadConfig). LOG_LEVEL=debug works ad-hoc when debugging.
+# LOG_LEVEL=info     # error | warn | info | debug
+# LOG_FORMAT=json    # text (default) | json