@pikku/cli 0.12.23 → 0.12.25

package/dist/src/fabric/functions/validate-core.d.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+export declare const FabricValidateInput: z.ZodObject<{}, z.core.$strip>;
+export declare const FabricValidateOutput: z.ZodObject<{
+    ok: z.ZodBoolean;
+    root: z.ZodString;
+    findings: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        severity: z.ZodEnum<{
+            info: "info";
+            warn: "warn";
+            error: "error";
+        }>;
+        message: z.ZodString;
+        path: z.ZodString;
+        fixHint: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare function runFabricValidate(startDir?: string): Promise<z.infer<typeof FabricValidateOutput>>;
+export declare const runValidate: typeof runFabricValidate;
+export declare const renderValidate: (_s: unknown, { ok, root, findings }: z.infer<typeof FabricValidateOutput>) => void;

package/dist/src/fabric/functions/validate-core.js

@@ -0,0 +1,227 @@
+import { existsSync } from 'node:fs';
+import { readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { z } from 'zod';
+import { added, changed, dim, removed } from '../lib/output.js';
+import { WorkspaceValidateOutput, readJsonSafe, readTextSafe, runWorkspaceValidate, } from '../../functions/validate/workspace-validate.js';
+export const FabricValidateInput = z.object({});
+export const FabricValidateOutput = WorkspaceValidateOutput;
+const POSTGRES_SQL_PATTERNS = [
+    {
+        re: /\b(?:SMALL|BIG)?SERIAL\b/i,
+        label: 'SERIAL / BIGSERIAL / SMALLSERIAL',
+    },
+    { re: /\bJSONB\b/i, label: 'JSONB' },
+    { re: /\bCREATE\s+SEQUENCE\b/i, label: 'CREATE SEQUENCE' },
+    { re: /\bgen_random_uuid\s*\(\s*\)/i, label: 'gen_random_uuid()' },
+    { re: /::[a-z_]+/i, label: ':: type cast' },
+    { re: /\bTSVECTOR\b/i, label: 'TSVECTOR' },
+    { re: /\bARRAY\s*\[/i, label: 'ARRAY[…]' },
+];
+export async function runFabricValidate(startDir = process.cwd()) {
+    const workspaceResult = await runWorkspaceValidate(startDir);
+    const root = workspaceResult.root;
+    const findings = [...workspaceResult.findings];
+    const e = (id, message, path, fixHint) => {
+        findings.push({ id, severity: 'error', message, path, fixHint });
+    };
+    const w = (id, message, path, fixHint) => {
+        findings.push({ id, severity: 'warn', message, path, fixHint });
+    };
+    const info = (id, message, path, fixHint) => {
+        findings.push({ id, severity: 'info', message, path, fixHint });
+    };
+    const fabricConfigPath = join(root, 'fabric.config.json');
+    const fabricConfig = await readJsonSafe(fabricConfigPath);
+    if (!fabricConfig) {
+        info('fabric-config-missing', 'fabric.config.json not found — project has not been linked to fabric yet', fabricConfigPath, 'Run `pikku fabric link` to create it, or create manually: {"projectId": "__PROJECT_ID__"}');
+    }
+    else if (!fabricConfig.projectId) {
+        info('fabric-config-no-project-id', 'fabric.config.json is missing "projectId"', fabricConfigPath, 'Add "projectId": "<your-project-id>" to fabric.config.json, or run `pikku fabric link`');
+    }
+    else if (fabricConfig.projectId === '__PROJECT_ID__') {
+        info('fabric-config-placeholder-project-id', 'fabric.config.json has a placeholder projectId ("__PROJECT_ID__") — project is not linked', fabricConfigPath, 'Run `pikku fabric link` to replace the placeholder with a real project ID');
+    }
+    const rootPkgPath = join(root, 'package.json');
+    const rootPkg = await readJsonSafe(rootPkgPath);
+    if (rootPkg) {
+        const allDeps = {
+            ...rootPkg.dependencies,
+            ...rootPkg.devDependencies,
+        };
+        if (!allDeps['@pikku/fabric-cli']) {
+            info('missing-fabric-cli', '@pikku/fabric-cli not in devDependencies — fabric CLI commands (validate, deploy) will not be available', rootPkgPath, 'Add "@pikku/fabric-cli" to devDependencies: use "file:./vendor/pikku-fabric-cli.tgz" (bundled release) or "portal:/path/to/pikku/packages/fabric-cli" (local dev)');
+        }
+    }
+    const fnDir = join(root, 'packages', 'functions');
+    const functionsSdkPkgName = (await readJsonSafe(join(root, 'packages', 'functions-sdk', 'package.json')))?.name;
+    const themePkgName = (await readJsonSafe(join(root, 'packages', 'theme', 'package.json')))?.name;
+    const componentsPkgName = (await readJsonSafe(join(root, 'packages', 'components', 'package.json')))?.name;
+    if (existsSync(fnDir)) {
+        const fnPkgPath = join(fnDir, 'package.json');
+        const fnPkg = await readJsonSafe(fnPkgPath);
+        if (fnPkg) {
+            const fnAllDeps = {
+                ...fnPkg.dependencies,
+                ...fnPkg.devDependencies,
+                ...fnPkg.peerDependencies,
+            };
+            if (fnAllDeps['@pikku/kysely-postgres']) {
+                e('fn-pkg-postgres-dep', '@pikku/kysely-postgres is in packages/functions dependencies — Fabric uses SQLite/libSQL (Turso), not PostgreSQL', fnPkgPath, 'Remove @pikku/kysely-postgres and use @pikku/kysely-sqlite with LibsqlWebDialect instead');
+            }
+        }
+        const servicesPath = join(fnDir, 'src', 'services.ts');
+        const servicesText = await readTextSafe(servicesPath);
+        if (servicesText) {
+            const usesKysely = /\bKysely\b/.test(servicesText);
+            const usesLibsql = servicesText.includes('@pikku/kysely-sqlite') ||
+                servicesText.includes('LibsqlWebDialect');
+            const usesProcessEnv = /\bprocess\.env\.[A-Z_]/.test(servicesText);
+            if (usesKysely && !usesLibsql) {
+                e('services-wrong-db-adapter', 'services.ts uses Kysely but not LibsqlWebDialect — Fabric injects a Turso/libSQL DATABASE_URL at runtime, not a PostgreSQL URL', servicesPath, 'Import LibsqlWebDialect from @pikku/kysely-sqlite and replace the dialect: new Kysely({ dialect: new LibsqlWebDialect({ url: databaseUrl }) })');
+            }
+            if (usesProcessEnv) {
+                info('services-process-env', 'services.ts reads process.env directly — prefer variables.get() for portable secret/variable access', servicesPath, 'Replace process.env.SOME_VAR with await variables.get("SOME_VAR") — declare the binding with wireVariable/wireSecret; process.env is fine for optional/non-secret config');
+            }
+            if (usesLibsql &&
+                rootPkg &&
+                !rootPkg.dependencies?.['@pikku/kysely-sqlite'] &&
+                !rootPkg.devDependencies?.['@pikku/kysely-sqlite']) {
+                e('missing-kysely-sqlite', 'services.ts imports @pikku/kysely-sqlite but it is not in root package.json', rootPkgPath, 'Add "@pikku/kysely-sqlite": "file:./vendor/pikku-kysely-sqlite.tgz" to dependencies');
+            }
+        }
+        // db/migrations/ — presence, numbering and SQL dialect
+        const migrationsDir = join(fnDir, 'db', 'migrations');
+        if (!existsSync(migrationsDir)) {
+            e('migrations-dir-missing', 'packages/functions/db/migrations/ not found', migrationsDir, 'Create db/migrations/ and add numbered .sql files (e.g. 0001-init.sql) using SQLite-compatible syntax');
+        }
+        else {
+            try {
+                const files = (await readdir(migrationsDir)).filter((f) => f.endsWith('.sql'));
+                const nums = [];
+                for (const f of files) {
+                    const m = f.match(/^(\d+)/);
+                    if (m)
+                        nums.push(parseInt(m[1], 10));
+                }
+                for (let idx = 1; idx < nums.length; idx++) {
+                    if (nums[idx] !== nums[idx - 1] + 1) {
+                        const missing = `${nums[idx - 1] + 1}..${nums[idx] - 1}`;
+                        e('migration-gap', `Migration numbering gap: IDs ${missing} are missing`, migrationsDir, 'Migrations must be consecutive. Add the missing .sql file or renumber if not yet applied.');
+                        break;
+                    }
+                }
+                for (const f of files) {
+                    const sql = await readTextSafe(join(migrationsDir, f));
+                    if (!sql)
+                        continue;
+                    const hits = POSTGRES_SQL_PATTERNS.filter(({ re }) => re.test(sql)).map(({ label }) => label);
+                    if (hits.length > 0) {
+                        e(`migration-postgres-sql-${f.replace(/[^a-z0-9]/gi, '-')}`, `${f} contains PostgreSQL syntax (${hits.join(', ')}) — Fabric uses SQLite/libSQL (Turso)`, join(migrationsDir, f), "Rewrite the migration using SQLite-compatible syntax: TEXT instead of JSONB, INTEGER PRIMARY KEY for auto-increment, datetime('now') instead of NOW(), no :: casts");
+                    }
+                }
+            }
+            catch {
+                // readdir failure — skip
+            }
+        }
+        // db/seed.sql
+        const seedPath = join(fnDir, 'db', 'seed.sql');
+        if (!existsSync(seedPath)) {
+            e('seed-sql-missing', 'packages/functions/db/seed.sql not found', seedPath, 'Create db/seed.sql with idempotent INSERT OR IGNORE statements for demo/test data');
+        }
+    }
+    const appsDir = join(root, 'apps');
+    if (existsSync(appsDir)) {
+        if (fabricConfig) {
+            const frontends = (fabricConfig.frontends ?? {});
+            for (const [slug, fe] of Object.entries(frontends)) {
+                const cwd = fe.cwd?.replace(/^\.\//, '');
+                if (cwd && !existsSync(join(root, cwd))) {
+                    e(`frontend-cwd-missing-${slug}`, `fabric.config.json frontend "${slug}" declares cwd "${cwd}" but that directory does not exist`, join(root, cwd), 'Create the directory or update the cwd in fabric.config.json');
+                }
+            }
+        }
+        let appEntries = [];
+        try {
+            appEntries = (await readdir(appsDir, { withFileTypes: true }))
+                .filter((e) => e.isDirectory())
+                .map((e) => e.name);
+        }
+        catch {
+            // ignore
+        }
+        const declaredCwds = fabricConfig
+            ? new Set(Object.values((fabricConfig.frontends ?? {})).map((f) => f.cwd?.replace(/^\.\//, '') ?? ''))
+            : null;
+        for (const name of appEntries) {
+            const appPath = join(appsDir, name);
+            const cwd = `apps/${name}`;
+            if (declaredCwds && !declaredCwds.has(cwd)) {
+                w(`app-not-declared-${name}`, `apps/${name} is not declared in fabric.config.json frontends`, appPath, `Add an entry to fabric.config.json: { "frontends": { "${name}": { "cwd": "${cwd}", "kind": "ssr" } } }`);
+            }
+            const appPkg = await readJsonSafe(join(appPath, 'package.json'));
+            if (!appPkg)
+                continue;
+            const appDeps = { ...appPkg.dependencies };
+            if (functionsSdkPkgName && !appDeps[functionsSdkPkgName]) {
+                info(`app-missing-functions-sdk-${name}`, `apps/${name} does not depend on ${functionsSdkPkgName} — the generated RPC client and React Query hooks`, join(appPath, 'package.json'), `Add "${functionsSdkPkgName}: workspace:*" to apps/${name}/package.json dependencies`);
+            }
+            if (themePkgName && !appDeps[themePkgName]) {
+                info(`app-missing-theme-${name}`, `apps/${name} does not depend on ${themePkgName}`, join(appPath, 'package.json'), `Add "${themePkgName}: workspace:*" to apps/${name}/package.json dependencies`);
+            }
+            if (componentsPkgName && !appDeps[componentsPkgName]) {
+                info(`app-missing-components-${name}`, `apps/${name} does not depend on ${componentsPkgName}`, join(appPath, 'package.json'), `Add "${componentsPkgName}: workspace:*" to apps/${name}/package.json dependencies`);
+            }
+        }
+    }
+    const designDocUrl = 'https://pikkufabric.dev/docs/design';
+    if (!existsSync(join(root, 'packages', 'theme'))) {
+        info('theme-missing', 'packages/theme/ not found — Fabric design features require a theme package', join(root, 'packages', 'theme'), `Create packages/theme/ with your Mantine theme tokens. See ${designDocUrl}`);
+    }
+    if (!existsSync(join(root, 'packages', 'components'))) {
+        info('components-missing', 'packages/components/ not found — Fabric design features require a components package', join(root, 'packages', 'components'), `Create packages/components/ with your shared UI components. See ${designDocUrl}`);
+    }
+    const ok = !findings.some((f) => f.severity === 'error');
+    return { ok, root, findings };
+}
+export const runValidate = runFabricValidate;
+export const renderValidate = (_s, { ok, root, findings }) => {
+    if (findings.length === 0) {
+        console.log(added('✓  All checks passed — project is fabric-compatible'));
+        return;
+    }
+    const relPath = (p) => p.startsWith(root + '/') || p.startsWith(root + '\\')
+        ? p.slice(root.length + 1)
+        : p;
+    const errors = findings.filter((f) => f.severity === 'error');
+    const warns = findings.filter((f) => f.severity === 'warn');
+    const infos = findings.filter((f) => f.severity === 'info');
+    for (const f of [...errors, ...warns, ...infos]) {
+        const icon = f.severity === 'error'
+            ? removed('✗')
+            : f.severity === 'warn'
+                ? changed('⚠')
+                : dim('ℹ');
+        console.log(`${icon}  ${f.message}`);
+        console.log(`   ${dim('path:')}   ${relPath(f.path)}`);
+        console.log(`   ${dim('fix:')}    ${f.fixHint}`);
+        console.log();
+    }
+    const counts = [];
+    if (errors.length) {
+        counts.push(removed(`${errors.length} error${errors.length !== 1 ? 's' : ''}`));
+    }
+    if (warns.length) {
+        counts.push(changed(`${warns.length} warning${warns.length !== 1 ? 's' : ''}`));
+    }
+    if (infos.length) {
+        counts.push(dim(`${infos.length} info${infos.length !== 1 ? 's' : ''}`));
+    }
+    console.log('─'.repeat(40));
+    console.log(counts.join('  '));
+    if (ok) {
+        console.log();
+        console.log(added('✓') + '  ' + dim('no errors — project can be linked to fabric'));
+    }
+};

package/dist/src/fabric/functions/validate.function.js

@@ -194,9 +194,12 @@ export async function runValidate(startDir = process.cwd()) {
                 e('missing-kysely-sqlite', 'services.ts imports @pikku/kysely-sqlite but it is not in root package.json', rootPkgPath, 'Add "@pikku/kysely-sqlite": "file:./vendor/pikku-kysely-sqlite.tgz" to dependencies');
             }
         }
-        // db/migrations/ — numbering and SQL dialect
+        // db/migrations/ — presence, numbering and SQL dialect
         const migrationsDir = join(fnDir, 'db', 'migrations');
-        if (existsSync(migrationsDir)) {
+        if (!existsSync(migrationsDir)) {
+            e('migrations-dir-missing', 'packages/functions/db/migrations/ not found', migrationsDir, 'Create db/migrations/ and add numbered .sql files (e.g. 0001-init.sql) using SQLite-compatible syntax');
+        }
+        else {
             try {
                 const files = (await readdir(migrationsDir))
                     .filter((f) => f.endsWith('.sql'))
@@ -210,7 +213,7 @@ export async function runValidate(startDir = process.cwd()) {
                 for (let idx = 1; idx < nums.length; idx++) {
                     if (nums[idx] !== nums[idx - 1] + 1) {
                         const missing = `${nums[idx - 1] + 1}..${nums[idx] - 1}`;
-                        e('migration-gap', `Migration numbering gap: IDs ${missing} are missing`, migrationsDir, 'Migrations must be consecutive (postgres-migrations refuses gaps). Add the missing .sql file or renumber if not yet applied.');
+                        e('migration-gap', `Migration numbering gap: IDs ${missing} are missing`, migrationsDir, 'Migrations must be consecutive. Add the missing .sql file or renumber if not yet applied.');
                         break;
                     }
                 }
@@ -229,6 +232,11 @@ export async function runValidate(startDir = process.cwd()) {
                 // readdir failure — skip
             }
         }
+        // db/seed.sql
+        const seedPath = join(fnDir, 'db', 'seed.sql');
+        if (!existsSync(seedPath)) {
+            e('seed-sql-missing', 'packages/functions/db/seed.sql not found', seedPath, 'Create db/seed.sql with idempotent INSERT OR IGNORE statements for demo/test data');
+        }
         // db.types.ts — should only re-export from .pikku
         const dbTypesPath = join(fnDir, 'src', 'types', 'db.types.ts');
         const dbTypesText = await readTextSafe(dbTypesPath);

package/dist/src/functions/commands/bootstrap.js

@@ -3,14 +3,14 @@ export const bootstrap = pikkuVoidFunc({
     remote: true,
     func: async ({ logger, getInspectorState }, _data, { rpc }) => {
         await getInspectorState(false, true, true);
-        await rpc.invoke('pikkuFunctionTypesSplit');
+        await rpc.invoke('pikkuFunctionTypesSplit', { bootstrap: true });
         await rpc.invoke('pikkuFunctionTypes');
         await rpc.invoke('pikkuHTTPTypes');
         await rpc.invoke('pikkuChannelTypes');
         await rpc.invoke('pikkuSchedulerTypes');
         await rpc.invoke('pikkuQueueTypes');
         await rpc.invoke('pikkuWorkflow', { bootstrap: true });
-        await rpc.invoke('pikkuTriggerTypes');
+        await rpc.invoke('pikkuTriggerTypes', { bootstrap: true });
         await rpc.invoke('pikkuMCPTypes');
         await rpc.invoke('pikkuAIAgentTypes');
         await rpc.invoke('pikkuNodeTypes');

package/dist/src/functions/commands/console.js

@@ -23,6 +23,9 @@ const MIME_TYPES = {
 export const consoleCommand = pikkuSessionlessFunc({
     remote: true,
     func: async ({ logger, config }, { port, open: openBrowser, hmr }, { rpc }) => {
+        const watchDirectories = [
+            ...new Set([config.emailTemplatesDir, ...config.srcDirectories].filter(Boolean)),
+        ];
         if (!config.scaffold?.console) {
             logger.error('Console is not enabled. Add { "scaffold": { "console": "no-auth" } } to your pikku.config.json');
             return;
@@ -68,19 +71,19 @@ export const consoleCommand = pikkuSessionlessFunc({
         });
         if (hmr) {
             await pikkuDevReloader({
-                srcDirectories: config.srcDirectories,
+                srcDirectories: watchDirectories,
                 logger,
             });
         }
-        const configWatcher = chokidar.watch(config.srcDirectories, {
+        const configWatcher = chokidar.watch(watchDirectories, {
             ignoreInitial: true,
             ignored: /.*\.gen\.tsx?/,
         });
         let watcher = new chokidar.FSWatcher({});
         const generatorWatcher = () => {
             watcher.close();
-            logger.info(`• Watching directories: \n  - ${config.srcDirectories.join('\n  - ')}`);
-            watcher = chokidar.watch(config.srcDirectories, {
+            logger.info(`• Watching directories: \n  - ${watchDirectories.join('\n  - ')}`);
+            watcher = chokidar.watch(watchDirectories, {
                 ignoreInitial: true,
                 ignored: /.*\.gen\.ts/,
             });

package/dist/src/functions/commands/db-migrate.js

@@ -3,10 +3,9 @@ import { resolveLocalDb, migrateAndCodegen } from '../db/local-db.js';
 import { loadUserConfigForDb } from './db-shared.js';
 export const dbMigrate = pikkuSessionlessFunc({
     remote: true,
-    func: async ({ logger, config, getInspectorState }) => {
+    func: async ({ logger, config }) => {
         const userConfig = await loadUserConfigForDb({
             config,
-            getInspectorState,
             logger,
         });
         if (!userConfig)
@@ -16,7 +15,7 @@ export const dbMigrate = pikkuSessionlessFunc({
             logger.error('pikku db migrate: dev.db is not configured in your pikku config.');
             throw new Error('dev.db not configured');
         }
-        const { migrate, codegen, zod } = migrateAndCodegen(resolved);
+        const { migrate, codegen, zod } = await migrateAndCodegen(resolved);
         if (migrate.applied.length === 0) {
             logger.info(`db migrate: no pending migrations (${migrate.skipped.length} already applied)`);
         }

package/dist/src/functions/commands/db-reset.js

@@ -3,10 +3,9 @@ import { resolveLocalDb, reset, migrateAndCodegen, seed, } from '../db/local-db.
 import { loadUserConfigForDb } from './db-shared.js';
 export const dbReset = pikkuSessionlessFunc({
     remote: true,
-    func: async ({ logger, config, getInspectorState }) => {
+    func: async ({ logger, config }) => {
         const userConfig = await loadUserConfigForDb({
             config,
-            getInspectorState,
             logger,
         });
         if (!userConfig)
@@ -18,7 +17,7 @@ export const dbReset = pikkuSessionlessFunc({
         }
         reset(resolved, config.rootDir);
         logger.info(`db reset: removed ${resolved.dbFile}`);
-        const { migrate, codegen, zod } = migrateAndCodegen(resolved);
+        const { migrate, codegen, zod } = await migrateAndCodegen(resolved);
         for (const name of migrate.applied) {
             logger.info(`db reset: applied ${name}`);
         }
@@ -28,7 +27,7 @@ export const dbReset = pikkuSessionlessFunc({
         logger.info(zod.written
             ? `db reset: regenerated ${zod.outFile} (${zod.tables.length} tables)`
             : `db reset: ${zod.outFile} unchanged`);
-        const seedResult = seed(resolved);
+        const seedResult = await seed(resolved);
         if (seedResult.applied) {
             logger.info(`db reset: seeded ${resolved.seedFile} (${seedResult.bytes} bytes)`);
         }

package/dist/src/functions/commands/db-seed.js

@@ -3,10 +3,9 @@ import { resolveLocalDb, seed } from '../db/local-db.js';
 import { loadUserConfigForDb } from './db-shared.js';
 export const dbSeed = pikkuSessionlessFunc({
     remote: true,
-    func: async ({ logger, config, getInspectorState }) => {
+    func: async ({ logger, config }) => {
         const userConfig = await loadUserConfigForDb({
             config,
-            getInspectorState,
             logger,
         });
         if (!userConfig)
@@ -16,7 +15,7 @@ export const dbSeed = pikkuSessionlessFunc({
             logger.error('pikku db seed: dev.db is not configured in your pikku config.');
             throw new Error('dev.db not configured');
         }
-        const result = seed(resolved);
+        const result = await seed(resolved);
         if (!result.applied) {
             logger.info(`db seed: no ${resolved.seedFile} found, nothing to do`);
         }

package/dist/src/functions/commands/db-shared.d.ts

@@ -8,25 +8,12 @@ export interface UserConfigShape {
 interface LoadOptions {
     config: {
         rootDir: string;
-        outDir: string;
+        srcDirectories: string[];
     };
-    getInspectorState: (refresh: boolean) => Promise<{
-        filesAndMethods: {
-            pikkuConfigFactory?: {
-                file: string;
-                variable: string;
-            };
-        };
-    }>;
     logger: {
         error: (msg: string) => void;
+        warn: (msg: string) => void;
     };
 }
-/**
- * Load the user's pikkuConfig the same way `dev.ts` does — through the
- * inspector state, then by importing the user's config factory file.
- * Returns `null` (and logs the error) if the project hasn't defined a
- * pikkuConfigFactory, so the caller can early-exit.
- */
 export declare function loadUserConfigForDb(options: LoadOptions): Promise<UserConfigShape | null>;
 export {};

package/dist/src/functions/commands/db-shared.js

@@ -1,25 +1,51 @@
-import { resolve } from 'path';
-import { loadUserBootstrap, loadUserModule } from './load-user-project.js';
-/**
- * Load the user's pikkuConfig the same way `dev.ts` does — through the
- * inspector state, then by importing the user's config factory file.
- * Returns `null` (and logs the error) if the project hasn't defined a
- * pikkuConfigFactory, so the caller can early-exit.
- */
+import { existsSync } from 'fs';
+import { resolve, join } from 'path';
+import { loadUserModule } from './load-user-project.js';
+function findUserConfigFactoryFile(rootDir, srcDirectories) {
+    for (const srcDir of srcDirectories) {
+        for (const name of ['config.ts', 'config.js']) {
+            const candidate = resolve(rootDir, srcDir, name);
+            if (existsSync(candidate))
+                return candidate;
+        }
+    }
+    for (const name of ['config.ts', 'config.js']) {
+        const candidate = join(rootDir, name);
+        if (existsSync(candidate))
+            return candidate;
+    }
+    return null;
+}
 export async function loadUserConfigForDb(options) {
-    const { config, getInspectorState, logger } = options;
-    const inspectorState = await getInspectorState(true);
-    const { pikkuConfigFactory } = inspectorState.filesAndMethods;
-    if (!pikkuConfigFactory) {
+    const { config, logger } = options;
+    const hasConventionalDbAssets = existsSync(join(config.rootDir, 'db', 'migrations')) ||
+        existsSync(join(config.rootDir, 'db', 'seed.sql'));
+    const configFactoryFile = findUserConfigFactoryFile(config.rootDir, config.srcDirectories);
+    if (!configFactoryFile) {
+        if (hasConventionalDbAssets) {
+            return { dev: { db: true } };
+        }
         logger.error('createConfig must be defined in your project');
         return null;
     }
-    const pikkuDir = resolve(config.rootDir, config.outDir);
-    await loadUserBootstrap(pikkuDir);
-    const configModule = await loadUserModule(pikkuConfigFactory.file);
-    const userCreateConfig = configModule[pikkuConfigFactory.variable];
+    let configModule;
+    try {
+        configModule = await loadUserModule(configFactoryFile);
+    }
+    catch (error) {
+        if (hasConventionalDbAssets) {
+            logger.warn(`Falling back to default local db config because '${configFactoryFile}' could not be loaded: ${error.message}`);
+            return { dev: { db: true } };
+        }
+        throw error;
+    }
+    const userCreateConfig = configModule.createConfig;
     if (typeof userCreateConfig !== 'function') {
-        logger.error(`Expected '${pikkuConfigFactory.variable}' in '${pikkuConfigFactory.file}' to be a function`);
+        if (hasConventionalDbAssets) {
+            logger.warn(`Falling back to default local db config because '${configFactoryFile}' does not export createConfig`);
+            return { dev: { db: true } };
+        }
+        logger.error(`Expected 'createConfig' in '${configFactoryFile}' to be a function`);
         return null;
     }
     return (await userCreateConfig());

package/dist/src/functions/commands/dev.js

@@ -3,7 +3,7 @@ import { join, resolve } from 'path';
 import { pikkuSessionlessFunc } from '#pikku';
 import chokidar from 'chokidar';
 import { pikkuDevReloader } from '@pikku/core/dev';
-import { ConsoleLogger, InMemoryQueueService, InMemoryWorkflowService, InMemoryTriggerService, InMemoryAIRunStateService, } from '@pikku/core/services';
+import { ConsoleLogger, LocalEmailService, InMemoryQueueService, InMemoryWorkflowService, InMemoryTriggerService, InMemoryAIRunStateService, } from '@pikku/core/services';
 import { KyselyAIStorageService, KyselyAIRunStateService, KyselyAgentRunService, } from '@pikku/kysely';
 import { stopSingletonServices } from '@pikku/core';
 import { pikkuState } from '@pikku/core/internal';
@@ -23,6 +23,9 @@ export const dev = pikkuSessionlessFunc({
         const hostname = 'localhost';
         const enableWatch = watch !== false;
         const enableHmr = hmr !== false;
+        const watchDirectories = [
+            ...new Set([config.emailTemplatesDir, ...config.srcDirectories].filter(Boolean)),
+        ];
         const commandSingletonServices = pikkuState(null, 'package', 'singletonServices');
         const commandFunctionMeta = {
             ...pikkuState(null, 'function', 'meta'),
@@ -49,7 +52,22 @@ export const dev = pikkuSessionlessFunc({
             const previousRPCMeta = pikkuState(null, 'rpc', 'meta');
             const previousWorkflowsMeta = pikkuState(null, 'workflows', 'meta');
             const previousWorkflowRegistrations = pikkuState(null, 'workflows', 'registrations');
-            pikkuState(null, 'package', 'singletonServices', commandSingletonServices);
+            // During hot-reload (when user services are already live), build a hybrid services
+            // object: user services (so in-flight requests keep kysely/content/etc.) overlaid
+            // with the CLI config (outDir, scaffold, schemaDirectory, etc. — required by
+            // allWorkflow for code generation paths). Replacing the entire services object with
+            // commandSingletonServices during hot-reload caused a race condition where concurrent
+            // auth requests saw CLI services (no kysely) and crashed.
+            const isHotReload = previousSingletonServices !== commandSingletonServices &&
+                !!previousSingletonServices;
+            const codegenServices = isHotReload
+                ? {
+                    ...previousSingletonServices,
+                    config: commandSingletonServices?.config ??
+                        previousSingletonServices.config,
+                }
+                : commandSingletonServices;
+            pikkuState(null, 'package', 'singletonServices', codegenServices);
             pikkuState(null, 'function', 'functions', new Map([...previousFunctions.entries(), ...commandFunctions.entries()]));
             pikkuState(null, 'function', 'meta', {
                 ...previousFunctionMeta,
@@ -98,7 +116,7 @@ export const dev = pikkuSessionlessFunc({
         const userCreateConfig = configModule[pikkuConfigFactory.variable];
         const userCreateSingletonServices = servicesModule[singletonServicesFactory.variable];
         const userConfig = await userCreateConfig();
-        const resolvedLocalDb = resolveLocalDb(userConfig.dev?.db, config.rootDir, config.outDir, config.runtimeDir);
+        const resolvedLocalDb = resolveLocalDb(userConfig.dev?.db ?? true, config.rootDir, config.outDir, config.runtimeDir);
         const kysely = resolvedLocalDb
             ? await createKysely(resolvedLocalDb)
             : undefined;
@@ -136,8 +154,10 @@ export const dev = pikkuSessionlessFunc({
         // single instance under both names so addons like @pikku/addon-console
         // can read runs in dev without projects having to wire their own backing
         // store.
+        const devLogger = new ConsoleLogger();
         const inMemoryServices = {
-            logger: new ConsoleLogger(),
+            logger: devLogger,
+            emailService: new LocalEmailService(),
             metaService: new LocalMetaService(pikkuDir),
             schedulerService,
             queueService: new InMemoryQueueService(),
@@ -190,20 +210,20 @@ export const dev = pikkuSessionlessFunc({
         });
         if (enableHmr) {
             await pikkuDevReloader({
-                srcDirectories: config.srcDirectories,
+                srcDirectories: watchDirectories,
                 logger,
             });
         }
         if (enableWatch) {
             const genIgnore = /\.gen\.tsx?$/;
-            configWatcher = chokidar.watch(config.srcDirectories, {
+            configWatcher = chokidar.watch(watchDirectories, {
                 ignoreInitial: true,
                 ignored: genIgnore,
             });
             const generatorWatcher = () => {
                 watcher?.close();
-                logger.info(`• Watching directories: \n  - ${config.srcDirectories.join('\n  - ')}`);
-                watcher = chokidar.watch(config.srcDirectories, {
+                logger.info(`• Watching directories: \n  - ${watchDirectories.join('\n  - ')}`);
+                watcher = chokidar.watch(watchDirectories, {
                     ignoreInitial: true,
                     ignored: genIgnore,
                 });

package/dist/src/functions/commands/emails-init.d.ts

@@ -0,0 +1,5 @@
+type EmailsInitInput = {
+    force?: boolean;
+};
+export declare const pikkuEmailsInit: import("#pikku").PikkuFunctionConfig<EmailsInitInput, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<EmailsInitInput, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<EmailsInitInput, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;
+export {};