@karmaniverous/smoz 0.2.5 → 0.2.7

package/dist/cli/index.cjs

@@ -5,10 +5,10 @@ var fs = require('node:fs');
 var path = require('node:path');
 var commander = require('commander');
 var packageDirectory = require('package-directory');
-var node_url = require('node:url');
 var chokidar = require('chokidar');
 var node_child_process = require('node:child_process');
 var os = require('node:os');
+var node_url = require('node:url');
 var node_process = require('node:process');
 var promises = require('node:readline/promises');
 
@@ -348,10 +348,19 @@ const spawnOffline = (root, cmd, verbose) => {
         env: baseEnv,
     });
     const prefix = '[offline] ';
+    let announced = false;
     const emit = (buf) => {
         const text = buf.toString('utf8');
         if (verbose)
             process.stdout.write(prefix + text);
+        // Detect the actual listening URL and announce it once to avoid "0" confusion.
+        const m = text.match(/listening on (https?:\/\/(?:localhost|127\.0\.0\.1):\d+)/i);
+        const url = m?.[1];
+        if (url && !announced) {
+            announced = true;
+            // Print a concise, canonical URL line.
+            process.stdout.write(`[dev] offline: ${url}\n`);
+        }
     };
     const emitErr = (buf) => {
         const text = buf.toString('utf8');
@@ -495,13 +504,17 @@ const collect = async (root) => {
     buckets.serverless.sort();
     return buckets;
 };
-const makeImports = (root, files) => {
-    return files.map((abs) => {
-        const rel = toPosix$1(path.relative(root, abs));
-        const noExt = withoutTsExt(rel);
-        return `import '@/${noExt}';`;
-    });
-};
+/**
+ * Build ESM import lines using POSIX-relative specifiers from the generated
+ * file directory (app/generated) to each target file. Avoids "@/" alias so
+ * dynamic import in the inline server works reliably under tsx.
+ */
+const makeImports = (root, outDir, files) => files.map((abs) => {
+    const relFromOut = toPosix$1(path.relative(outDir, abs));
+    const noExt = withoutTsExt(relFromOut);
+    const spec = noExt.startsWith('.') ? noExt : `./${noExt}`;
+    return `import '${spec}';`;
+});
 const buildFile = (imports) => {
     if (imports.length === 0)
         return `${HEADER}\n`;
@@ -509,10 +522,10 @@ const buildFile = (imports) => {
 };
 const runRegister = async (root) => {
     const buckets = await collect(root);
-    const lambdaImports = makeImports(root, buckets.lambda);
-    const openapiImports = makeImports(root, buckets.openapi);
-    const serverlessImports = makeImports(root, buckets.serverless);
     const outDir = path.join(root, 'app', 'generated');
+    const lambdaImports = makeImports(root, outDir, buckets.lambda);
+    const openapiImports = makeImports(root, outDir, buckets.openapi);
+    const serverlessImports = makeImports(root, outDir, buckets.serverless);
     const fnsPath = path.join(outDir, 'register.functions.ts');
     const oaiPath = path.join(outDir, 'register.openapi.ts');
     const srvPath = path.join(outDir, 'register.serverless.ts');
@@ -529,11 +542,146 @@ const runRegister = async (root) => {
     return { wrote };
 };
 
-/* Dev loop orchestrator
- * - Watches author sources; debounces bursts; runs tasks in order: register → openapi.
- * - Optional local serving (--local inline|offline).
- * - Stage/env: seeds process.env with concrete values for the selected stage.
- */
+const inferDefaultStage = (root, verbose) => {
+    // Prefer “dev”; explicit --stage overrides remain available.
+    if (verbose)
+        console.log('[dev] inferring stage: dev (explicit --stage overrides)');
+    return 'dev';
+};
+const seedEnvForStage = async (root, stage, verbose) => {
+    // Best effort: import the app config to read declared env keys and concrete values.
+    // Preserve existing process.env values; only seed when unset.
+    try {
+        const appConfigUrl = node_url.pathToFileURL(path.resolve(root, 'app', 'config', 'app.config.ts')).href;
+        // Dynamically import the TS module under tsx
+        const mod = (await import(appConfigUrl));
+        const app = mod.app;
+        const stages = mod.stages;
+        const globalKeys = Array.isArray(app?.global?.envKeys)
+            ? app.global.envKeys
+            : [];
+        const stageKeys = Array.isArray(app?.stage?.envKeys)
+            ? app.stage.envKeys
+            : [];
+        const globalParams = (stages?.default).params ?? {};
+        const stageParams = (stages?.[stage]).params ?? {};
+        const seedPair = (key, from) => {
+            if (key in process.env)
+                return;
+            const val = from[key];
+            if (val === undefined)
+                return;
+            if (typeof val === 'string') {
+                process.env[key] = val;
+                if (verbose)
+                    console.log(`[dev] env: ${key}=${val}`);
+                return;
+            }
+            if (typeof val === 'number' || typeof val === 'boolean') {
+                const v = String(val);
+                process.env[key] = v;
+                if (verbose)
+                    console.log(`[dev] env: ${key}=${v}`);
+                return;
+            }
+            // Non-primitive; skip to avoid [object Object] surprise.
+            if (verbose)
+                console.log(`[dev] env: skip ${key} (non-primitive)`);
+        };
+        for (const k of globalKeys) {
+            if (typeof k === 'string') {
+                seedPair(k, globalParams);
+            }
+        }
+        for (const k of stageKeys) {
+            if (typeof k === 'string') {
+                seedPair(k, stageParams);
+            }
+        }
+        // Ensure STAGE itself is present as a last resort
+        if (!process.env.STAGE) {
+            process.env.STAGE = stage;
+            if (verbose)
+                console.log(`[dev] env: STAGE=${stage}`);
+        }
+    }
+    catch {
+        // Fallback: seed STAGE only
+        if (!process.env.STAGE) {
+            process.env.STAGE = stage;
+            if (verbose)
+                console.log(`[dev] env: STAGE=${stage}`);
+        }
+    }
+};
+
+const resolveTsxCommand = (root, tsEntry) => {
+    const localCli = path.resolve(root, 'node_modules', 'tsx', 'dist', 'cli.js');
+    if (fs.existsSync(localCli)) {
+        // Normalize to POSIX separators for cross-platform comparisons (tests)
+        const localCliPosix = localCli.split(path.sep).join('/');
+        return {
+            cmd: process.execPath,
+            args: [localCliPosix, tsEntry],
+            shell: false,
+        };
+    }
+    const probe = node_child_process.spawnSync(process.platform === 'win32' ? 'tsx.cmd' : 'tsx', ['--version'], { shell: true });
+    if (typeof probe.status === 'number' && probe.status === 0) {
+        return {
+            cmd: process.platform === 'win32' ? 'tsx.cmd' : 'tsx',
+            args: [tsEntry],
+            shell: true,
+        };
+    }
+    throw new Error('Inline requires tsx. Install it with "npm i -D tsx", or run "smoz dev -l offline".');
+};
+const launchInline = async (root, opts) => {
+    // Resolve the installed smoz package root robustly (works from compiled CLI and tsx ESM):
+    // Prefer __dirname when available (CJS), otherwise derive from import.meta.url (ESM).
+    const here = typeof __dirname === 'string'
+        ? __dirname
+        : path.dirname(node_url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href))));
+    const pkgRoot = packageDirectory.packageDirectorySync({ cwd: here }) ?? process.cwd();
+    const tsEntry = path.resolve(pkgRoot, 'src', 'cli', 'local', 'inline.server', 'index.ts');
+    const makeTsx = () => {
+        const { cmd, args, shell } = resolveTsxCommand(root, tsEntry);
+        return node_child_process.spawn(cmd, args, {
+            cwd: root,
+            stdio: 'inherit',
+            shell,
+            // Enable tsconfig paths for "@/..." during TS fallback.
+            env: {
+                ...process.env,
+                TSX_TSCONFIG_PATHS: '1',
+                SMOZ_STAGE: opts.stage,
+                SMOZ_PORT: String(opts.port),
+                SMOZ_VERBOSE: opts.verbose ? '1' : '',
+            },
+        });
+    };
+    let child = makeTsx();
+    const close = async () => new Promise((resolve) => {
+        // If the process has already exited (exitCode set), resolve immediately.
+        if (child.exitCode !== null) {
+            resolve();
+            return;
+        }
+        child.once('exit', () => {
+            resolve();
+        });
+        child.kill('SIGTERM');
+        setTimeout(() => {
+            resolve();
+        }, 1500);
+    });
+    const restart = async () => {
+        await close();
+        child = makeTsx();
+    };
+    return { close, restart };
+};
+
 const runDev = async (root, opts) => {
     const verbose = !!opts.verbose;
     const stage = typeof opts.stage === 'string'
@@ -547,7 +695,8 @@ const runDev = async (root, opts) => {
         if (verbose)
             console.warn('[dev] env seeding warning:', e.message);
     }
-    const mode = opts.local;
+    const modeInitial = opts.local;
+    const mode = modeInitial;
     const port = typeof opts.port === 'number' ? opts.port : 0;
     if (verbose) {
         console.log(`[dev] options: register=${String(opts.register)} ` +
@@ -633,8 +782,10 @@ const runDev = async (root, opts) => {
         offline = await launchOffline(root, { stage, port, verbose });
     }
     else if (mode === 'inline') {
+        // Hard error on failure; no fallback to offline.
         inlineChild = await launchInline(root, { stage, port, verbose });
-    } // Watch sources
+    }
+    // Watch sources
     const globs = [
         path.join(root, 'app', 'functions', '**', 'lambda.ts'),
         path.join(root, 'app', 'functions', '**', 'openapi.ts'),
@@ -667,130 +818,6 @@ const runDev = async (root, opts) => {
         });
     });
 };
-const inferDefaultStage = (root, verbose) => {
-    // Prefer “dev”; if app.config.ts is available and we can inspect it cheaply later, expand behavior.
-    // For now, return 'dev' (explicit selection via --stage remains available).
-    if (verbose)
-        console.log('[dev] inferring stage: dev (explicit --stage overrides)');
-    return 'dev';
-};
-const seedEnvForStage = async (root, stage, verbose) => {
-    // Best effort: import the app config to read declared env keys and concrete values.
-    // Preserve existing process.env values; only seed when unset.
-    try {
-        const appConfigUrl = node_url.pathToFileURL(path.resolve(root, 'app', 'config', 'app.config.ts')).href;
-        // Dynamically import the TS module under tsx
-        const mod = (await import(appConfigUrl));
-        const app = mod.app;
-        const stages = mod.stages;
-        const globalKeys = Array.isArray(app?.global?.envKeys)
-            ? app.global.envKeys
-            : [];
-        const stageKeys = Array.isArray(app?.stage?.envKeys)
-            ? app.stage.envKeys
-            : [];
-        const globalParams = (stages?.default).params ?? {};
-        const stageParams = (stages?.[stage]).params ?? {};
-        const seedPair = (key, from) => {
-            if (key in process.env)
-                return;
-            const val = from[key];
-            if (val === undefined)
-                return;
-            if (typeof val === 'string') {
-                process.env[key] = val;
-                if (verbose)
-                    console.log(`[dev] env: ${key}=${val}`);
-                return;
-            }
-            if (typeof val === 'number' || typeof val === 'boolean') {
-                const v = String(val);
-                process.env[key] = v;
-                if (verbose)
-                    console.log(`[dev] env: ${key}=${v}`);
-                return;
-            }
-            // Non-primitive; skip to avoid [object Object] surprise.
-            if (verbose)
-                console.log(`[dev] env: skip ${key} (non-primitive)`);
-        };
-        for (const k of globalKeys) {
-            if (typeof k === 'string') {
-                seedPair(k, globalParams);
-            }
-        }
-        for (const k of stageKeys) {
-            if (typeof k === 'string') {
-                seedPair(k, stageParams);
-            }
-        }
-        // Ensure STAGE itself is present as a last resort
-        if (!process.env.STAGE) {
-            process.env.STAGE = stage;
-            if (verbose)
-                console.log(`[dev] env: STAGE=${stage}`);
-        }
-    }
-    catch {
-        // Fallback: seed STAGE only
-        if (!process.env.STAGE) {
-            process.env.STAGE = stage;
-            if (verbose)
-                console.log(`[dev] env: STAGE=${stage}`);
-        }
-    }
-};
-// Inline local runner: spawn tsx to run a TS server script.
-const launchInline = async (root, opts) => {
-    const { spawn } = await import('node:child_process');
-    const path = await import('node:path');
-    const fs = await import('node:fs');
-    const tsxCli = path.resolve(root, 'node_modules', 'tsx', 'dist', 'cli.js');
-    const entry = path.resolve(root, 'src', 'cli', 'local', 'inline.server.ts');
-    if (!fs.existsSync(entry)) {
-        throw new Error('inline server entry missing: src/cli/local/inline.server.ts');
-    }
-    const args = [tsxCli, entry];
-    if (!fs.existsSync(tsxCli)) {
-        // Fallback to PATH resolution
-        args.shift();
-        args.unshift(process.platform === 'win32' ? 'tsx.cmd' : 'tsx');
-    }
-    else {
-        args.unshift(process.execPath);
-    }
-    const spawnChild = () => spawn(args[0], args.slice(1), {
-        cwd: root,
-        stdio: 'inherit',
-        shell: !args[0].endsWith('.js'),
-        env: {
-            ...process.env,
-            SMOZ_STAGE: opts.stage,
-            SMOZ_PORT: String(opts.port),
-            SMOZ_VERBOSE: opts.verbose ? '1' : '',
-        },
-    });
-    let child = spawnChild();
-    const close = async () => new Promise((resolve) => {
-        // If the process has already exited (exitCode set), resolve immediately.
-        if (child.exitCode !== null) {
-            resolve();
-            return;
-        }
-        child.once('exit', () => {
-            resolve();
-        });
-        child.kill('SIGTERM');
-        setTimeout(() => {
-            resolve();
-        }, 1500);
-    });
-    const restart = async () => {
-        await close();
-        child = spawnChild();
-    };
-    return { close, restart };
-};
 
 const writeIfAbsent = async (outFile, content) => {
     if (fs.existsSync(outFile))
@@ -1426,7 +1453,7 @@ const main = () => {
         .option('-l, --local [mode]', 'Local server mode: inline|offline', 'inline')
         .option('-s, --stage <name>', 'Stage name (default inferred)')
         .option('-p, --port <n>', 'Port (0=random)', (v) => Number(v), 0)
-        .option('-v, --verbose', 'Verbose logging', false)
+        .option('-V, --verbose', 'Verbose logging', false)
         .action(async (opts) => {
         try {
             const cfg = readSmozConfig(root).cliDefaults?.dev ?? {};

package/dist/mjs/cli/inline-server.js

@@ -0,0 +1,296 @@
+import http from 'node:http';
+import { URL, pathToFileURL } from 'node:url';
+import path from 'node:path';
+
+const firstVal = (v) => Array.isArray(v) ? v[0] : v;
+const arrVal = (v) => typeof v === 'string' ? [v] : Array.isArray(v) ? v : undefined;
+const toHeaders = (raw) => {
+    const single = {};
+    const multi = {};
+    for (const [k, v] of Object.entries(raw)) {
+        const fv = firstVal(v);
+        const av = arrVal(v);
+        if (typeof fv === 'string')
+            single[k] = fv;
+        if (Array.isArray(av))
+            multi[k] = av;
+    }
+    return { single, multi };
+};
+const readBody = (req) => new Promise((resolve) => {
+    const chunks = [];
+    req.on('data', (c) => chunks.push(Buffer.isBuffer(c) ? c : Buffer.from(String(c))));
+    req.on('end', () => {
+        resolve(Buffer.concat(chunks).toString('utf8'));
+    });
+    req.on('error', () => {
+        resolve('');
+    });
+});
+const match = (segs, pathName) => {
+    const parts = pathName
+        .replace(/^\/+|\/+$/g, '')
+        .split('/')
+        .filter(Boolean);
+    if (parts.length !== segs.length)
+        return { ok: false, params: {} };
+    const params = {};
+    for (let i = 0; i < segs.length; i += 1) {
+        const seg = segs[i];
+        const p = parts[i];
+        if (seg.literal) {
+            if (seg.literal !== p)
+                return { ok: false, params: {} };
+        }
+        else if (seg.key) {
+            params[seg.key] = p;
+        }
+    }
+    return { ok: true, params };
+};
+const toEvent = async (req, route, params) => {
+    const url = new URL(req.url ?? '/', `http://${req.headers.host ?? 'localhost'}`);
+    const { single, multi } = toHeaders(req.headers);
+    const method = (req.method ?? '').toUpperCase();
+    const stage = process.env.SMOZ_STAGE ?? 'dev';
+    const search = new URLSearchParams(url.search);
+    const query = {};
+    const mquery = {};
+    for (const key of Array.from(new Set(search.keys()))) {
+        const vals = search.getAll(key);
+        if (vals.length > 0) {
+            query[key] = vals[0];
+            mquery[key] = vals;
+        }
+    }
+    let body = '';
+    if (method !== 'GET' && method !== 'HEAD') {
+        body = await readBody(req);
+    }
+    return {
+        httpMethod: method,
+        headers: single,
+        multiValueHeaders: multi,
+        body,
+        isBase64Encoded: false,
+        path: url.pathname,
+        queryStringParameters: Object.keys(query).length ? query : {},
+        multiValueQueryStringParameters: Object.keys(mquery).length ? mquery : {},
+        pathParameters: Object.keys(params).length ? params : {},
+        stageVariables: null,
+        resource: route.pattern,
+        requestContext: {
+            accountId: 'acc',
+            apiId: 'inline',
+            httpMethod: method,
+            identity: {},
+            path: url.pathname,
+            stage,
+            requestId: String(Date.now()),
+            requestTimeEpoch: Date.now(),
+            resourceId: 'res',
+            resourcePath: route.pattern,
+            authorizer: {},
+            protocol: 'HTTP/1.1',
+        },
+    };
+};
+const writeResult = (res, result) => {
+    const status = typeof result.statusCode === 'number' ? result.statusCode : 200;
+    const headers = result.headers ?? {};
+    const body = typeof result.body === 'string' ? result.body : '';
+    for (const [k, v] of Object.entries(headers)) {
+        if (typeof v === 'string')
+            res.setHeader(k, v);
+    }
+    res.statusCode = status;
+    res.end(body);
+};
+
+/**
+ * Load downstream registers to populate the app registry.
+ * Tries TS/JS candidates and logs which one was loaded when SMOZ_VERBOSE is set.
+ */
+const loadRegisters = async (root) => {
+    const candidates = [
+        path.resolve(root, 'app', 'generated', 'register.functions.ts'),
+        path.resolve(root, 'app', 'generated', 'register.functions.mts'),
+        path.resolve(root, 'app', 'generated', 'register.functions.js'),
+        path.resolve(root, 'app', 'generated', 'register.functions.mjs'),
+    ];
+    for (const p of candidates) {
+        try {
+            const url = pathToFileURL(p).href;
+            await import(url);
+            if (process.env.SMOZ_VERBOSE) {
+                const rel = path.relative(root, p).split(path.sep).join('/');
+                console.log('[inline] registers loaded:', rel);
+            }
+            return;
+        }
+        catch {
+            // try next candidate
+        }
+    }
+    console.warn('[inline] Could not load app/generated/register.functions.*. Run "npx smoz register" before inline dev.');
+};
+/**
+ * Load the App instance (TS source) from the downstream project.
+ * Returns only the surface needed by the inline server.
+ */
+const loadApp = async (root) => {
+    const p = path.resolve(root, 'app', 'config', 'app.config.ts');
+    const url = pathToFileURL(p).href;
+    const mod = (await import(url));
+    const app = mod.app;
+    if (!app || typeof app.buildAllServerlessFunctions !== 'function') {
+        throw new Error('Failed to load app/config/app.config.ts (missing export "app").');
+    }
+    return app;
+};
+
+const splitPattern = (p) => p
+    .replace(/\\/g, '/')
+    .replace(/^\/+|\/+$/g, '')
+    .split('/')
+    .filter(Boolean)
+    .map((s) => s.startsWith('{') && s.endsWith('}')
+    ? { key: s.slice(1, -1) }
+    : { literal: s });
+/**
+ * Build route table from the downstream app's aggregated serverless functions.
+ */
+const loadHandlers = async (root, app) => {
+    const fns = app.buildAllServerlessFunctions();
+    const routes = [];
+    for (const [, defUnknown] of Object.entries(fns)) {
+        const def = defUnknown;
+        if (typeof def.handler !== 'string' || !Array.isArray(def.events))
+            continue;
+        const [moduleRel, exportName] = (() => {
+            const lastDot = def.handler.lastIndexOf('.');
+            if (lastDot < 0)
+                return [def.handler, 'handler'];
+            return [
+                def.handler.slice(0, lastDot),
+                def.handler.slice(lastDot + 1),
+            ];
+        })();
+        // Resolve TS source module; dev runs via tsx so TS imports are OK
+        const candidates = [
+            path.resolve(root, `${moduleRel}.ts`),
+            path.resolve(root, `${moduleRel}.mts`),
+            path.resolve(root, `${moduleRel}.js`),
+            path.resolve(root, `${moduleRel}.mjs`),
+        ];
+        // Always try the first candidate (TS is expected in authoring).
+        const modUrl = pathToFileURL(candidates[0]).href;
+        const mod = (await import(modUrl));
+        const handler = mod[exportName];
+        if (typeof handler !== 'function')
+            continue;
+        for (const evt of def.events) {
+            const httpEvt = evt
+                .http;
+            const method = (httpEvt?.method ?? '').toUpperCase();
+            const pattern = '/' + (httpEvt?.path ?? '').replace(/^\/+/, '');
+            if (!method || !pattern)
+                continue;
+            routes.push({
+                method,
+                pattern,
+                segs: splitPattern(pattern),
+                handlerRef: `${moduleRel}.${exportName}`,
+                handler: handler,
+            });
+        }
+    }
+    return routes;
+};
+
+/**
+ * Inline HTTP dev server (module entry).
+ *
+ * Decomposed from the original single-file implementation to improve
+ * readability and maintainability:
+ * - loaders.ts: register/app loaders
+ * - routes.ts: route table construction
+ * - http.ts: request/event mapping helpers
+ */
+const start = async () => {
+    const root = process.cwd();
+    // Ensure register side-effects are loaded so the registry has routes
+    await loadRegisters(root);
+    // Load the App instance from the same TS source as the registers
+    const app = await loadApp(root);
+    const routes = await loadHandlers(root, app);
+    const portEnv = process.env.SMOZ_PORT;
+    const port = typeof portEnv === 'string' && portEnv.length > 0 ? Number(portEnv) : 0;
+    const server = http.createServer((req, res) => {
+        void (async () => {
+            try {
+                const method = (req.method ?? '').toUpperCase();
+                const url = new URL(req.url ?? '/', `http://${req.headers.host ?? 'localhost'}`);
+                // Allow HEAD to match GET routes; the wrapped handler/middleware will
+                // short-circuit HEAD requests to 200 {} and set Content-Type.
+                const searchMethod = method === 'HEAD' ? 'GET' : method;
+                const route = routes.find((r) => r.method === searchMethod && match(r.segs, url.pathname).ok);
+                if (!route) {
+                    res.statusCode = 404;
+                    res.setHeader('Content-Type', 'application/json');
+                    res.end(JSON.stringify({ error: 'Not Found' }));
+                    return;
+                }
+                const { params } = match(route.segs, url.pathname);
+                const evt = await toEvent(req, route, params);
+                const result = await route.handler(evt, {
+                    awsRequestId: String(Date.now()),
+                    callbackWaitsForEmptyEventLoop: false,
+                    functionName: 'inline',
+                    functionVersion: '$LATEST',
+                    invokedFunctionArn: 'arn:inline',
+                    logGroupName: 'lg',
+                    logStreamName: 'ls',
+                    memoryLimitInMB: '256',
+                    getRemainingTimeInMillis: () => 30000,
+                    done: () => undefined,
+                    fail: () => undefined,
+                    succeed: () => undefined,
+                });
+                writeResult(res, result);
+            }
+            catch (e) {
+                res.statusCode = 500;
+                res.setHeader('Content-Type', 'application/json');
+                res.end(JSON.stringify({ error: e.message }));
+            }
+        })();
+    });
+    server.listen(port, () => {
+        const addr = server.address();
+        const resolved = typeof addr === 'object' && addr && 'port' in addr
+            ? addr.port
+            : port;
+        // Print route table
+        // Keep output consistent with existing tests:
+        // "[inline] listening on http://localhost:<port>"
+        console.log('[inline] listening on http://localhost:' + String(resolved));
+        const header = '[inline] routes:\n';
+        if (routes.length === 0) {
+            console.log(header + '  (none found)');
+        }
+        else {
+            const body = routes
+                .map((r) => '  ' +
+                r.method.padEnd(6) +
+                ' ' +
+                r.pattern +
+                '  ->  ' +
+                r.handlerRef)
+                .join('\n');
+            console.log(header + body);
+        }
+    });
+};
+// Start immediately when run via tsx
+void start();

package/package.json

@@ -181,5 +181,5 @@
     "templates:lint": "eslint --fix -c templates/default/eslint.config.ts \"templates/default/**/*.{ts,tsx,js,jsx}\" \"templates/default/eslint.config.ts\""
   },
   "type": "module",
-  "version": "0.2.5"
+  "version": "0.2.7"
 }

package/templates/default/eslint.config.ts

@@ -9,6 +9,18 @@ import { fileURLToPath } from 'url';
 const tsconfigRootDir = dirname(fileURLToPath(import.meta.url));
 
 export default [
+  {
+    ignores: [
+      '.serverless/**',
+      '.stan/**',
+      '**/.tsbuild/**',
+      '**/generated/**',
+      'coverage/**',
+      'dist/**',
+      'docs/**',
+      'node_modules/**',
+    ],
+  },
   eslint.configs.recommended,
   ...tseslint.configs.strictTypeChecked,
   prettierConfig,

package/templates/default/serverless.ts

@@ -107,9 +107,6 @@ const config: AWS = {
     versionFunctions: false,
   },
   functions: app.buildAllServerlessFunctions() as NonNullable<AWS['functions']>,
-  // Optional esbuild configuration (parity with /app fixture):
-  // These booleans are driven by global params in app.config.ts:
-  //   ESB_MINIFY, ESB_SOURCEMAP
   build: {
     esbuild: {
       bundle: true,

package/templates/default/tsconfig.downstream.json

@@ -7,12 +7,7 @@
     },
     "tsBuildInfoFile": ".tsbuild/tsconfig.tsbuildinfo"
   },
-  "exclude": [
-    ".serverless/**",
-    "node_modules/**",
-    "app/generated/**",
-    "dist/**"
-  ],
+  "exclude": [".serverless/**", "node_modules/**", "app/generated/**"],
   "extends": "./tsconfig.base.json",
   "include": ["**/*", "**/*.json"]
 }