rimecms 0.28.10 → 0.30.0

package/dist/core/config/server/validate.server.js

@@ -1,13 +1,15 @@
 import { isAuthConfig } from '../../collections/auth/util.js';
 import cache from '../../dev/cache/index.server.js';
 import { isFormField } from '../../fields/util.js';
-import { logger } from '../../logger/index.server';
-import { isBlocksFieldRaw } from '../../../fields/blocks/index.js';
-import { isGroupFieldRaw } from '../../../fields/group/index.js';
-import { isRelationField } from '../../../fields/relation';
-import { isSelectField } from '../../../fields/select/index.js';
-import { isTabsFieldRaw } from '../../../fields/tabs';
-import { isTreeFieldRaw } from '../../../fields/tree/index.js';
+import { logger } from '../../logger/index.server.js';
+import { withoutDirectoriesSuffix, withoutVersionsSuffix } from '../../naming.js';
+import { BlocksBuilder } from '../../../fields/blocks/index.js';
+import { GroupFieldBuilder } from '../../../fields/group/index.js';
+import { RelationFieldBuilder } from '../../../fields/relation/index.js';
+import { SelectFieldBuilder } from '../../../fields/select/index.js';
+import { TabsBuilder } from '../../../fields/tabs/index.js';
+import { TreeBuilder } from '../../../fields/tree/index.js';
+import { isCamelCase } from '../../../util/string.js';
 function hasDuplicates(arr) {
     return [...new Set(arr.filter((e, i, a) => a.indexOf(e) !== i))];
 }
@@ -29,6 +31,24 @@ function hasDuplicateSlug(config) {
     }
     return [];
 }
+/**
+ * Check that all area/collection slugs are camelCase
+ */
+function validateSlugs(config) {
+    const errors = [];
+    const slugs = [
+        ...(config.collections || []).map((c) => c.slug),
+        ...(config.areas || []).map((a) => a.slug)
+    ]
+        .map(withoutVersionsSuffix)
+        .map(withoutDirectoriesSuffix);
+    for (const slug of slugs) {
+        if (!isCamelCase(slug)) {
+            errors.push(`Slug ${slug} is not a valid prototype slug`);
+        }
+    }
+    return errors;
+}
 /**
  * Prevent the panel user collection slug
  * to be used elsewhere
@@ -64,14 +84,14 @@ const validateDocumentFields = (documentConfig, config) => {
     const isCollection = (documentConfig) => documentConfig.type === 'collection';
     const isAuth = isCollection(documentConfig) && isAuthConfig(documentConfig);
     const registeredBlocks = {};
-    const fieldsCompiled = documentConfig.fields.map((f) => f.compile());
+    // const fieldsCompiled = documentConfig.fields.map((f) => f.compile());
     if (isAuth) {
-        const rolesField = fieldsCompiled
+        const rolesField = documentConfig.fields
             .filter(isFormField)
             .filter((f) => f.name === 'roles')
-            .filter((f) => isSelectField(f))[0];
-        const nameField = fieldsCompiled.filter(isFormField).filter((f) => f.name === 'name')[0];
-        const emailField = fieldsCompiled
+            .filter((f) => f instanceof SelectFieldBuilder)[0];
+        const nameField = documentConfig.fields.filter(isFormField).filter((f) => f.name === 'name')[0];
+        const emailField = documentConfig.fields
             .filter(isFormField)
             .find((f) => f.name === 'email' && f.type === 'email');
         if (!rolesField)
@@ -80,7 +100,7 @@ const validateDocumentFields = (documentConfig, config) => {
             errors.push(`Field email is missing in collection ${documentConfig.slug}`);
         if (!nameField)
             errors.push(`Field name is missing in collection ${documentConfig.slug}`);
-        if (!rolesField.many)
+        if (!rolesField.get.many)
             errors.push(`Field roles must have "many" enabled : select('roles').options(...).many(), even with a single option`);
     }
     const validateBlockField = (fields, blockType) => {
@@ -96,8 +116,8 @@ const validateDocumentFields = (documentConfig, config) => {
     };
     const validateRelationField = (field) => {
         const collectionsSlugs = (config.collections || []).map((c) => c.slug);
-        if (!collectionsSlugs.includes(field.relationTo)) {
-            errors.push(`Relation field ${field.name} references unknown collection ${field.relationTo}, in ${documentConfig.type} ${documentConfig.slug}`);
+        if (!collectionsSlugs.includes(field.get.relationTo)) {
+            errors.push(`Relation field ${field.name} references unknown collection ${field.get.relationTo}, in ${documentConfig.type} ${documentConfig.slug}`);
         }
     };
     const validateFields = (fields) => {
@@ -116,17 +136,17 @@ const validateDocumentFields = (documentConfig, config) => {
             return pattern.test(name) && !name.includes('-') && !name.includes(' ');
         }
         function validateTabs(field) {
-            const duplicates = hasDuplicates(field.tabs.map((t) => t.name));
+            const duplicates = hasDuplicates(field.get.tabs.map((t) => t.name));
             if (duplicates.length) {
                 errors.push(`Dupplicate tab name ${duplicates} in ${documentConfig.slug}`);
             }
         }
         for (const field of fields) {
             // Recursive check first into Tabs since tabs are not Formfields
-            if (isTabsFieldRaw(field)) {
+            if (field instanceof TabsBuilder) {
                 validateTabs(field);
-                for (const tab of field.tabs) {
-                    validateFields(tab.fields);
+                for (const tab of field.get.tabs) {
+                    validateFields(tab.get.fields);
                 }
             }
             // If field is not a Formfield eg. Separator then continue
@@ -134,7 +154,7 @@ const validateDocumentFields = (documentConfig, config) => {
                 continue;
             }
             // Check that a field wich has field._root = true is not localized
-            if ('_root' in field && field._root && field.localized) {
+            if (field.get.root && field.get.localized) {
                 errors.push(`Field ${field.name} of ${documentConfig.type} ${documentConfig.slug} with _root = true, can't be localized`);
             }
             // Check for malformed field.name
@@ -142,8 +162,8 @@ const validateDocumentFields = (documentConfig, config) => {
                 errors.push(`Field ${field.name} of ${documentConfig.type} ${documentConfig.slug} should be camelCase`);
             }
             // Recursive check into Blocks
-            if (isBlocksFieldRaw(field)) {
-                for (const block of field.blocks) {
+            if (field instanceof BlocksBuilder) {
+                for (const block of field.get.blocks) {
                     if (block.name in registeredBlocks) {
                         const blockDefinedButDiffer = JSON.stringify(registeredBlocks[block.name]) !== JSON.stringify(block);
                         if (blockDefinedButDiffer) {
@@ -153,25 +173,25 @@ const validateDocumentFields = (documentConfig, config) => {
                     else {
                         registeredBlocks[block.name] = block;
                     }
-                    validateFields(block.fields.filter(isFormField));
-                    validateBlockField(block.fields.filter(isFormField), block.name);
+                    validateFields(block.get.fields.filter(isFormField));
+                    validateBlockField(block.get.fields.filter(isFormField), block.name);
                 }
                 // Recursive check into Tree
             }
-            else if (isTreeFieldRaw(field)) {
-                validateFields(field.fields.filter(isFormField));
+            else if (field instanceof TreeBuilder) {
+                validateFields(field.get.fields.filter(isFormField));
                 // Recursive check into Tabs
             }
-            else if (isGroupFieldRaw(field)) {
-                validateFields(field.fields.filter(isFormField));
+            else if (field instanceof GroupFieldBuilder) {
+                validateFields(field.get.fields.filter(isFormField));
                 // Check relation field
             }
-            else if (isRelationField(field)) {
+            else if (field instanceof RelationFieldBuilder) {
                 validateRelationField(field);
             }
         }
     };
-    validateFields(documentConfig.fields.map((f) => f.compile()));
+    validateFields(documentConfig.fields);
     return errors;
 };
 const hasDatabase = (config) => {
@@ -192,9 +212,9 @@ function validateAuthCollections(config) {
     return errors;
 }
 function validate(config) {
-    logger.debug('Validating config...');
     const validateFunctions = [
         hasDuplicateSlug,
+        validateSlugs,
         hasUsersSlug,
         validateFields,
         hasDatabase,

package/dist/core/config/shared/find-thumbnail.js

@@ -1,29 +1,29 @@
 import { FormFieldBuilder } from '../../fields/builders/form-field-builder.js';
-import { isGroupField } from '../../../fields/group/index.js';
-import { RelationFieldBuilder } from '../../../fields/relation';
+import { GroupFieldBuilder } from '../../../fields/group/index.js';
+import { RelationFieldBuilder } from '../../../fields/relation/index.js';
 import { TabsBuilder } from '../../../fields/tabs/index.js';
 export function findThumbnailField(fields = [], basePath = '') {
     for (const field of fields) {
         // Direct check for isThumbnail
         if (field instanceof RelationFieldBuilder &&
-            'isThumbnail' in field.raw &&
-            field.raw.isThumbnail === true) {
-            const path = basePath ? `${basePath}.${field.raw.name}` : field.raw.name;
+            'isThumbnail' in field.get &&
+            field.get.isThumbnail === true) {
+            const path = basePath ? `${basePath}.${field.name}` : field.name;
             return { field, path };
         }
         // Check in group
-        if (isGroupField(field.raw) && field.raw.fields) {
-            const groupPath = basePath ? `${basePath}.${field.raw.name}` : field.raw.name;
-            const found = findThumbnailField(field.raw.fields, groupPath);
+        if (field instanceof GroupFieldBuilder && field.get.fields) {
+            const groupPath = basePath ? `${basePath}.${field.name}` : field.name;
+            const found = findThumbnailField(field.get.fields, groupPath);
             if (found)
                 return found;
         }
         // Check in tabs
-        if (field instanceof TabsBuilder && field.raw.tabs) {
-            for (const tab of field.raw.tabs) {
-                if (tab.raw.fields) {
-                    const tabPath = basePath ? `${basePath}.${tab.raw.name}` : tab.raw.name;
-                    const found = findThumbnailField(tab.raw.fields, tabPath);
+        if (field instanceof TabsBuilder && field.get.tabs) {
+            for (const tab of field.get.tabs) {
+                if (tab.get.fields) {
+                    const tabPath = basePath ? `${basePath}.${tab.name}` : tab.name;
+                    const found = findThumbnailField(tab.get.fields, tabPath);
                     if (found)
                         return found;
                 }

package/dist/core/config/shared/find-title.js

@@ -1,30 +1,30 @@
 import { FormFieldBuilder } from '../../fields/builders/form-field-builder.js';
-import { isGroupField } from '../../../fields/group/index.js';
+import { GroupFieldBuilder } from '../../../fields/group/index.js';
 import { TabsBuilder } from '../../../fields/tabs/index.js';
 export const hasMaybeTitle = (field) => ['text', 'date', 'slug', 'email', 'richText'].includes(field.type);
 export function findTitleField(fields = [], basePath = '') {
     for (const field of fields) {
         // Direct check for isTitle
         if (field instanceof FormFieldBuilder &&
-            hasMaybeTitle(field.raw) &&
-            'isTitle' in field.raw &&
-            field.raw.isTitle === true) {
-            const path = basePath ? `${basePath}.${field.raw.name}` : field.raw.name;
+            hasMaybeTitle(field.get) &&
+            'isTitle' in field.get &&
+            field.get.isTitle === true) {
+            const path = basePath ? `${basePath}.${field.name}` : field.name;
             return { field, path };
         }
         // Check in group
-        if (isGroupField(field.raw) && field.raw.fields) {
-            const groupPath = basePath ? `${basePath}.${field.raw.name}` : field.raw.name;
-            const found = findTitleField(field.raw.fields, groupPath);
+        if (field instanceof GroupFieldBuilder && field.get.fields) {
+            const groupPath = basePath ? `${basePath}.${field.name}` : field.name;
+            const found = findTitleField(field.get.fields, groupPath);
             if (found)
                 return found;
         }
         // Check in tabs
-        if (field instanceof TabsBuilder && field.raw.tabs) {
-            for (const tab of field.raw.tabs) {
-                if (tab.raw.fields) {
-                    const tabPath = basePath ? `${basePath}.${tab.raw.name}` : tab.raw.name;
-                    const found = findTitleField(tab.raw.fields, tabPath);
+        if (field instanceof TabsBuilder && field.get.tabs) {
+            for (const tab of field.get.tabs) {
+                if (tab.get.fields) {
+                    const tabPath = basePath ? `${basePath}.${tab.name}` : tab.name;
+                    const found = findTitleField(tab.get.fields, tabPath);
                     if (found)
                         return found;
                 }

package/dist/core/config/shared/upload-directories.js

@@ -10,7 +10,7 @@ export function makeUploadDirectoriesCollectionClient(collection) {
     const slug = withDirectoriesSuffix(collection.slug);
     const directoriesConfig = collection.upload.directories;
     // else create the directory collection
-    let directoriesCollection = {
+    const directoriesCollection = {
         slug: slug,
         kebab: withDirectoriesSuffix(collection.kebab),
         versions: undefined,

package/dist/core/constant.d.ts

@@ -37,7 +37,7 @@ export declare const PARAMS: {
     readonly SORT: "sort";
     /** GET / UPDATE a specific version*/
     readonly VERSION_ID: "versionId";
-    /** Parameter for panel collection list to filter out documents from a specific uploadPath */
+    /** On fetch (upload) list operation filter out documents from a specific uploadPath */
     readonly UPLOAD_PATH: "uploadPath";
     /**
      * Disable validation on CREATE / UPDATE operations

package/dist/core/constant.js

@@ -37,7 +37,7 @@ export const PARAMS = {
     SORT: 'sort',
     /** GET / UPDATE a specific version*/
     VERSION_ID: 'versionId',
-    /** Parameter for panel collection list to filter out documents from a specific uploadPath */
+    /** On fetch (upload) list operation filter out documents from a specific uploadPath */
     UPLOAD_PATH: 'uploadPath',
     /**
      * Disable validation on CREATE / UPDATE operations

package/dist/core/constant.server.d.ts

@@ -1 +1,2 @@
 export declare const PACKAGE_NAME = "rimecms";
+export declare const RIME_DEV_CACHE_DIR: string;

package/dist/core/constant.server.js

@@ -1 +1,3 @@
+import path from 'path';
 export const PACKAGE_NAME = 'rimecms';
+export const RIME_DEV_CACHE_DIR = path.resolve(process.cwd(), 'node_modules', '.rime');

package/dist/core/dev/cache/index.server.js

@@ -1,12 +1,12 @@
+import { RIME_DEV_CACHE_DIR } from '../../constant.server';
 import fs from 'fs';
 import path from 'path';
 const dev = process.env.NODE_ENV === 'development';
-const cachePath = path.resolve(process.cwd(), '.rime');
-if (!fs.existsSync(cachePath) && dev) {
-    fs.mkdirSync(cachePath);
+if (!fs.existsSync(RIME_DEV_CACHE_DIR) && dev) {
+    fs.mkdirSync(RIME_DEV_CACHE_DIR);
 }
 function get(key) {
-    const keyPath = path.join(cachePath, key + '.txt');
+    const keyPath = path.join(RIME_DEV_CACHE_DIR, key + '.txt');
     const exist = fs.existsSync(keyPath);
     if (exist) {
         return fs.readFileSync(keyPath).toString();
@@ -14,20 +14,20 @@ function get(key) {
     return false;
 }
 function set(key, value) {
-    if (!fs.existsSync(cachePath)) {
-        fs.mkdirSync(cachePath);
+    if (!fs.existsSync(RIME_DEV_CACHE_DIR)) {
+        fs.mkdirSync(RIME_DEV_CACHE_DIR);
     }
-    const keyPath = path.join(cachePath, key + '.txt');
+    const keyPath = path.join(RIME_DEV_CACHE_DIR, key + '.txt');
     fs.writeFileSync(keyPath, value);
 }
 function del(key) {
-    const keyPath = path.join(cachePath, key + '.txt');
+    const keyPath = path.join(RIME_DEV_CACHE_DIR, key + '.txt');
     if (fs.existsSync(keyPath)) {
         fs.rmSync(keyPath, { force: true });
     }
 }
 function clear() {
-    fs.rmSync(cachePath, { recursive: true });
+    fs.rmSync(RIME_DEV_CACHE_DIR, { recursive: true });
 }
 export default {
     get,

package/dist/core/dev/cli/build/index.d.ts

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
 export declare const build: (args: {
     withDatabase?: boolean;
+    withEnv?: boolean;
 }) => void;

package/dist/core/dev/cli/build/index.js

@@ -1,8 +1,22 @@
 #!/usr/bin/env node
+import { logger } from '../../../logger/index.server.js';
+import chalk from 'chalk';
 import { spawnSync } from 'child_process';
 import { copyFileSync, cpSync, existsSync, mkdirSync, renameSync, rmSync, writeFileSync } from 'fs';
-import { polkaServer } from './templates.js';
-import { logger } from '../../../logger/index.server.js';
+import { getInvokingPackageManager } from '../util/package-manager.server.js';
+import { envProduction, polkaServer } from './templates.js';
+const installCommands = {
+    pnpm: {
+        addDeps: 'pnpm install polka sharp serve-static',
+        prodInstall: 'pnpm install --prod',
+        runEnv: 'pnpm rime env'
+    },
+    npm: {
+        addDeps: 'npm install polka sharp serve-static',
+        prodInstall: 'npm install --omit=dev',
+        runEnv: 'npx rime env'
+    }
+};
 export const build = (args) => {
     // Delete app folder if it exists
     if (existsSync('./app')) {
@@ -24,13 +38,28 @@ export const build = (args) => {
         cpSync('./db', './app/db', { recursive: true });
         logger.info('[✓] database copied');
     }
+    // Create main entry server file
     writeFileSync('./app/index.js', polkaServer);
     logger.info('[✓] polka server created at app/index.js');
+    // Create .env file if flag is set
+    const envContent = envProduction();
+    if (args.withEnv) {
+        writeFileSync('./app/.env', envContent);
+        logger.info('[✓] .env file created at app/.env');
+    }
+    console.log('----------------------------------------------------------------\n');
+    console.log('## Next steps :');
+    console.log('');
+    console.log('    cd ./app');
+    const pm = getInvokingPackageManager() === 'pnpm' ? 'pnpm' : 'npm';
+    if (!args.withEnv) {
+        console.log('    ' +
+            installCommands[pm].runEnv +
+            ' ' +
+            chalk.dim(`# next time run \`${pm === 'pnpm' ? 'pnpm' : 'npx'} rime build -e\` to generate the .env file automatically`));
+    }
+    console.log('    ' + installCommands[pm].addDeps);
+    console.log('    ' + installCommands[pm].prodInstall);
     console.log('');
-    logger.info('Next steps :');
-    logger.info('create a /app/.env file with ORIGIN HOST and PORT variables');
-    logger.info('cd ./app');
-    logger.info('pnpm install --prod');
-    logger.info('pnpm install polka sharp serve-static');
-    logger.info('node --env-file=.env index.js');
+    console.log('    node --env-file=.env index.js');
 };

package/dist/core/dev/cli/build/templates.d.ts

@@ -1 +1,2 @@
+export declare const envProduction: () => string;
 export declare const polkaServer = "import polka from 'polka';\nimport serveStatic from 'serve-static';\nimport { handler } from './build/handler.js';\n\nconst serve = serveStatic('./static');\n\nconst port = process.env.PORT || 3000;\nconst host = process.env.HOST || '127.0.0.1';\n\npolka()\n\t.use(serve)\n\t.use(handler)\n\t.listen(port, host, () => {\n\t\tconsole.log(`server running on ${host}:${port}`);\n\t});\n";

package/dist/core/dev/cli/build/templates.js

@@ -1,3 +1,27 @@
+import { randomId } from '../../../../util/random.js';
+export const envProduction = () => `# BETTER-AUTH
+BETTER_AUTH_SECRET=${randomId(32)}
+
+# RIME
+PUBLIC_RIME_URL=http://localhost:3000
+RIME_LOG_LEVEL=ERROR
+RIME_LOG_TO_FILE=true
+RIME_CACHE_ENABLED=true
+RIME_CACHE_STRATEGY=memory
+
+# RIME_SMTP_USER=user@host.org
+# RIME_SMTP_PASSWORD=somepassword
+# RIME_SMTP_HOST=smtp.host
+# RIME_SMTP_PORT=465
+
+# SVELTEKIT ADAPTER-NODE
+ORIGIN=http://localhost:3000
+PORT=3000
+HOST=localhost
+
+# MISC
+BODY_SIZE_LIMIT=10485760 # 10(MB) * 1024 * 1024 = 10485760 bytes
+`;
 export const polkaServer = `import polka from 'polka';
 import serveStatic from 'serve-static';
 import { handler } from './build/handler.js';

package/dist/core/dev/cli/clear/index.server.js

@@ -1,8 +1,9 @@
+import { RIME_DEV_CACHE_DIR } from '../../../constant.server.js';
 import { logger } from '../../../logger/index.server.js';
 import { rmSync } from 'node:fs';
 import path from 'node:path';
 import { INPUT_DIR, OUTPUT_DIR } from '../../constants.js';
-import { prompt } from '../util.server.js';
+import { prompt } from '../util/prompt.server.js';
 const clearMessage = `Are you sure you want to delete all related rime files (Y/n):
 - ./static/medias
 - ./db
@@ -24,7 +25,7 @@ export const clear = async (args) => {
         return logger.info('Operation cancelled. Great!');
     }
     // Remove directories
-    rmSync(path.join('.rime'), { recursive: true, force: true });
+    rmSync(RIME_DEV_CACHE_DIR, { recursive: true, force: true });
     rmSync(path.join('src', 'routes', '(rime)'), { recursive: true, force: true });
     rmSync(path.join('src', 'lib', INPUT_DIR), { recursive: true, force: true });
     rmSync(path.join('src', 'lib', OUTPUT_DIR), { recursive: true, force: true });

package/dist/core/dev/cli/generate/index.server.js

@@ -1,3 +1,4 @@
+import { RIME_DEV_CACHE_DIR } from '../../../constant.server';
 import cache from '../../cache/index.server.js';
 import { sanitize } from '../../generate/sanitize/index.server.js';
 import { ensureGeneratedConfig, ensureUserConfigExist } from '../../../ensure.server.js';
@@ -12,8 +13,8 @@ export const generate = async (args) => {
      */
     function clearConfigCache() {
         try {
-            rmSync(path.join(process.cwd(), '.rime'), { recursive: true, force: true });
-            mkdirSync(path.join(process.cwd(), '.rime'));
+            rmSync(RIME_DEV_CACHE_DIR, { recursive: true, force: true });
+            mkdirSync(RIME_DEV_CACHE_DIR);
         }
         catch (err) {
             logger.error(err.message);

package/dist/core/dev/cli/index.js

@@ -1,5 +1,8 @@
 #!/usr/bin/env node
+import { logger } from '../../logger/index.server.js';
 import { program } from 'commander';
+import { existsSync, writeFileSync } from 'fs';
+import { envProduction } from './build/templates.js';
 program.version('0.1').description('CMS utilities');
 program.description('Rime utilities');
 program
@@ -14,6 +17,7 @@ program
 program
     .command('build')
     .option('-d, --with-database', 'Include database', false)
+    .option('-e, --with-env', 'Create the /app/.env file from the production template', false)
     .action(async (args) => {
     const build = await import('./build/index.js').then((m) => m.build);
     build(args);
@@ -39,4 +43,20 @@ program
         process.exitCode = 1;
     }
 });
+program
+    .command('env')
+    .option('-f, --force', 'Force generation, overwrite current', false)
+    .action(async (args) => {
+    try {
+        if (existsSync('./.env') && !args.force) {
+            logger.info('.env file already exists. Use --force to overwrite.');
+            return;
+        }
+        writeFileSync('./.env', envProduction());
+        logger.info('[✓] .env file created');
+    }
+    catch {
+        process.exitCode = 1;
+    }
+});
 program.parse(process.argv);

package/dist/core/dev/cli/init/index.server.js

@@ -11,9 +11,9 @@ import path from 'path';
 import { fileURLToPath } from 'url';
 import { INPUT_DIR } from '../../constants.js';
 import { generate } from '../generate/index.server.js';
-import { prompt } from '../util.server.js';
-import { getPackageInfoByKey } from './get-package-info.server.js';
-import { installDependencies } from './package-manager-util.server.js';
+import { installDependencies } from '../util/package-manager.server.js';
+import { getPackageInfoByKey } from '../util/package.server.js';
+import { prompt } from '../util/prompt.server.js';
 import * as templates from './templates.js';
 const PACKAGE = 'rimecms';
 const root = process.cwd();
@@ -83,7 +83,7 @@ export const init = async ({ force, name: incomingName, skipInstall }) => {
             return;
         }
         let gitignoreContent = readFileSync(gitignorePath, 'utf-8');
-        const updates = ['\\.rime', '\\.cache', '/logs', '/db', '\\+rime.generated'];
+        const updates = ['\\.cache', '/logs', '/db', '\\+rime.generated'];
         if (!gitignoreContent.includes('# rime'))
             gitignoreContent += '\n# rime';
         for (const line of updates) {

package/dist/core/dev/cli/init/templates.d.ts

@@ -1,4 +1,4 @@
 export declare const env: () => string;
 export declare const defaultConfig: (name: string) => string;
 export declare const drizzleConfig: (name: string) => string;
-export declare const hooks = "import { sequence } from '@sveltejs/kit/hooks';\nimport { handlers } from 'rimecms';\nimport config from './lib/+rime.generated/rime.config.server.js';\n\nexport const handle = sequence(...(await handlers(config)));\n";
+export declare const hooks = "import { sequence } from '@sveltejs/kit/hooks';\nimport { handlers } from 'rimecms/server';\nimport config from './lib/+rime.generated/rime.config.server.js';\n\nexport const handle = sequence(...(await handlers(config)));\n";

package/dist/core/dev/cli/init/templates.js

@@ -18,7 +18,7 @@ RIME_LOG_TO_FILE_MAX_DAYS=1
 export const defaultConfig = (name) => `
 import { Collection, rime } from '$rime/config';
 import { text } from '${PACKAGE}/fields';
-import { adapterSqlite } from '${PACKAGE}/sqlite';
+import { adapterSqlite } from '${PACKAGE}/adapter-sqlite';
 
 const Pages = Collection.create('pages', {
 	fields: [text('title').isTitle()]
@@ -45,7 +45,7 @@ export const config: Config = {
 export default defineConfig(config);
 `;
 export const hooks = `import { sequence } from '@sveltejs/kit/hooks';
-import { handlers } from '${PACKAGE}';
+import { handlers } from '${PACKAGE}/server';
 import config from './lib/${OUTPUT_DIR}/rime.config.server.js';
 
 export const handle = sequence(...(await handlers(config)));

package/dist/core/dev/cli/util/log.server.d.ts

@@ -0,0 +1 @@
+export declare const dim: (text: string) => void;

package/dist/core/dev/cli/util/log.server.js

@@ -0,0 +1,4 @@
+import chalk from 'chalk';
+export const dim = (text) => {
+    console.log(chalk.dim(text));
+};

package/dist/core/dev/cli/util/package-manager.server.d.ts

@@ -0,0 +1,9 @@
+export type PackageManagerName = 'yarn' | 'pnpm' | 'bun' | 'npm' | 'deno';
+export declare function getPackageManager(): PackageManagerName;
+/**
+ * Detects the package manager used to invoke the currently running command
+ * (e.g. `pnpm rime build` vs `npx rime build`), based on the user agent npm/pnpm/yarn/bun
+ * set on the child process. Falls back to npm, which is also what npx reports.
+ */
+export declare function getInvokingPackageManager(): PackageManagerName;
+export declare function installDependencies(): void;

package/dist/core/dev/cli/{init/package-manager-util.server.js → util/package-manager.server.js}

@@ -39,6 +39,21 @@ export function getPackageManager() {
     }
     return 'npm';
 }
+/**
+ * Detects the package manager used to invoke the currently running command
+ * (e.g. `pnpm rime build` vs `npx rime build`), based on the user agent npm/pnpm/yarn/bun
+ * set on the child process. Falls back to npm, which is also what npx reports.
+ */
+export function getInvokingPackageManager() {
+    const userAgent = process.env.npm_config_user_agent;
+    if (!userAgent)
+        return 'npm';
+    const name = userAgent.split('/')[0];
+    if (name === 'pnpm' || name === 'yarn' || name === 'bun' || name === 'npm' || name === 'deno') {
+        return name;
+    }
+    return 'npm';
+}
 export function installDependencies() {
     const pm = getPackageManager();
     if (pm === 'deno' || pm === 'yarn') {

package/dist/core/dev/cli/util/package.server.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Vite (and every other rime command) resolves everything relative to cwd and
+ * fails when run from elsewhere (e.g. `vite build` from ./app errors with
+ * "Cannot resolve entry module index.html"). package.json alone isn't a
+ * reliable root marker since the build command copies one into ./app too;
+ * src/ is only ever present at the real project root.
+ */
+export declare function isProjectRoot(cwd?: string): boolean;
+export declare function getPackageInfoByKey(key: string): string;

package/dist/core/dev/cli/{init/get-package-info.server.js → util/package.server.js}

@@ -1,5 +1,15 @@
 import path from 'path';
 import fs from 'fs';
+/**
+ * Vite (and every other rime command) resolves everything relative to cwd and
+ * fails when run from elsewhere (e.g. `vite build` from ./app errors with
+ * "Cannot resolve entry module index.html"). package.json alone isn't a
+ * reliable root marker since the build command copies one into ./app too;
+ * src/ is only ever present at the real project root.
+ */
+export function isProjectRoot(cwd = process.cwd()) {
+    return fs.existsSync(path.join(cwd, 'package.json')) && fs.existsSync(path.join(cwd, 'src'));
+}
 export function getPackageInfoByKey(key) {
     try {
         // Read the package.json file