rimecms 0.31.4 → 0.32.0

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

@@ -0,0 +1,98 @@
+import { RIME_DEV_CACHE_DIR } from '../../../constants.server.js';
+import cache from '../../cache.server.js';
+import { sanitize } from '../../codegen/sanitize/index.server.js';
+import { ensureGeneratedConfig, ensureUserConfigExist } from '../../ensure.server.js';
+import { regenerateModulesDeclaration } from '../../vite.server.js';
+import { logger } from '../../../logger.server.js';
+import { trycatch } from '../../../../util/function.js';
+import { mkdirSync, rmSync } from 'fs';
+import path from 'path';
+export const generate = async (args) => {
+    const { force } = args;
+    /**
+     * Clear the cached .rime folder
+     */
+    function clearConfigCache() {
+        try {
+            rmSync(RIME_DEV_CACHE_DIR, { recursive: true, force: true });
+            mkdirSync(RIME_DEV_CACHE_DIR);
+        }
+        catch (err) {
+            logger.error(err.message);
+        }
+    }
+    /*
+     * Delete routes/(rime) folder
+     */
+    function clearRoutes() {
+        try {
+            rmSync(path.join(process.cwd(), 'src', 'routes', '(rime)'), { recursive: true, force: true });
+        }
+        catch (err) {
+            logger.error(err.message);
+        }
+    }
+    /**
+     * Sanitize the user config and create the config.generated folder
+     */
+    async function sanitizeConfig() {
+        await sanitize();
+    }
+    /**
+     * Create the vite devServer
+     */
+    async function createServer() {
+        const { createServer } = await import('vite');
+        // Create a Vite server using the project's vite.config.ts
+        const vite = await createServer({
+            configFile: path.join(process.cwd(), 'vite.config.ts'),
+            server: {
+                hmr: false,
+                middlewareMode: true
+            },
+            optimizeDeps: { disabled: true },
+            appType: 'custom',
+            logLevel: 'error'
+        });
+        return vite;
+    }
+    async function run() {
+        if (force) {
+            clearConfigCache();
+            clearRoutes();
+        }
+        // Mark that a CLI generation is in flight, so a concurrently running dev
+        // server doesn't race us on the shared .rime cache (see rime.server.ts).
+        process.env.RIME_CLI = 'true';
+        cache.set('.cli', new Date().toISOString());
+        try {
+            ensureUserConfigExist();
+            await sanitizeConfig();
+            // Normal `vite dev` writes this from `configureServer`'s `listening` event, which never
+            // fires here — this command's own Vite server runs in `middlewareMode` (no `httpServer`).
+            regenerateModulesDeclaration();
+            const importPathJS = ensureGeneratedConfig();
+            logger.info('Starting vite server...');
+            const vite = await createServer();
+            try {
+                const mod = await vite.ssrLoadModule(importPathJS);
+                // The generated config's default export is the createRime() promise;
+                // ssrLoadModule only awaits the module's synchronous evaluation, so we
+                // must await it directly to observe init failures (e.g. config validation).
+                await mod.default;
+                logger.info('[✓] Generation completed successfully');
+            }
+            finally {
+                await vite.close();
+            }
+        }
+        finally {
+            cache.delete('.cli');
+        }
+    }
+    const [error] = await trycatch(run);
+    if (error) {
+        logger.error('[✗] Error during generation:', error);
+        throw error;
+    }
+};

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

@@ -0,0 +1,242 @@
+import { logger } from '../../../logger.server.js';
+import { PANEL_ROUTE } from '../../../routes/constants.server.js';
+import { randomId } from '../../../../util/random.js';
+import { isValidSlug, slugify } from '../../../../util/string.js';
+import { generate as generateCode } from '@babel/generator';
+import * as t from '@babel/types';
+import { babelParse, getLang } from 'ast-kit';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { cp, mkdir } from 'fs/promises';
+import fs from 'node:fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { CONFIG_DIR, OUTPUT_DIR } from '../../constants.server.js';
+import * as templates from '../templates/init.js';
+import { installDependencies } from '../util/package-manager.server.js';
+import { getPackageInfoByKey } from '../util/package.server.js';
+import { prompt } from '../util/prompt.server.js';
+import { generate } from './generate.server.js';
+const PACKAGE = 'rimecms';
+const root = process.cwd();
+export const init = async ({ force, name: incomingName, skipInstall }) => {
+    const packageName = getPackageInfoByKey('name');
+    function setEnv() {
+        const envPath = path.resolve(root, '.env');
+        // Define variables with their update behavior
+        const envUpdates = {
+            BETTER_AUTH_SECRET: randomId(32),
+            PUBLIC_RIME_URL: 'http://localhost:5173',
+            RIME_CONFIG_DIR: CONFIG_DIR,
+            RIME_PANEL_ROUTE: PANEL_ROUTE,
+            '# RIME_SMTP_USER': 'user@mail.com',
+            '# RIME_SMTP_PASSWORD': 'supersecret',
+            '# RIME_SMTP_PORT': '465',
+            '# RIME_SMTP_HOST': 'smtphost.com',
+            RIME_LOG_LEVEL: 'TRACE',
+            RIME_LOG_TO_FILE: 'true',
+            RIME_LOG_TO_FILE_MAX_DAYS: '1'
+        };
+        if (existsSync(envPath)) {
+            logger.info('[✓] .env file found');
+            let envContent = readFileSync(envPath, 'utf-8');
+            Object.entries(envUpdates).forEach(([key, value]) => {
+                const exists = envContent.match(new RegExp(`^${key}=`, 'm'));
+                if (!exists) {
+                    // Add new value if doesn't exist
+                    envContent += `\n${key}=${value}`;
+                    logger.info(`- ${key} added`);
+                }
+            });
+            writeFileSync(envPath, envContent);
+            logger.info('[✓] .env file populated');
+        }
+        else {
+            writeFileSync(envPath, templates.env());
+            logger.info('[✓] .env file created');
+        }
+    }
+    function setConfig(name) {
+        const configDirPath = path.resolve(root, CONFIG_DIR);
+        const configPath = path.join(configDirPath, 'rime.config.server.ts');
+        if (!existsSync(configPath)) {
+            if (!existsSync(configDirPath)) {
+                mkdirSync(configDirPath);
+            }
+            writeFileSync(configPath, templates.defaultConfig(name.toString()));
+            logger.info(`[✓] Config created at ${configDirPath}/rime.config.server.ts`);
+        }
+        else {
+            logger.info('[✓] Config already exists (skip)');
+        }
+    }
+    function setDatabase() {
+        const dbPath = path.join(root, 'db');
+        if (!existsSync(dbPath)) {
+            mkdirSync(dbPath);
+            logger.info('[✓] Database folder created');
+        }
+        else {
+            logger.info('[✓] Database folder already exists (skip)');
+        }
+    }
+    function addToGitignore() {
+        const gitignorePath = path.join(root, '.gitignore');
+        if (!existsSync(gitignorePath)) {
+            logger.warn('.gitignore not found (skip)');
+            return;
+        }
+        let gitignoreContent = readFileSync(gitignorePath, 'utf-8');
+        // OUTPUT_DIR is derived from RIME_CONFIG_DIR, so its first character isn't always '+' —
+        // escape every regex metacharacter generically instead of hand-picking one to backslash.
+        const escapeRegExp = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        const updates = [
+            '.cache',
+            '/logs',
+            '/db',
+            OUTPUT_DIR,
+            'src/app.generated.d.ts',
+            'src/rime.generated.d.ts'
+        ];
+        if (!gitignoreContent.includes('# rime'))
+            gitignoreContent += '\n# rime';
+        for (const line of updates) {
+            const exists = gitignoreContent.match(new RegExp(`^${escapeRegExp(line)}`, 'm'));
+            if (!exists) {
+                // Add new value if doesn't exist
+                gitignoreContent += `\n${line}`;
+            }
+        }
+        writeFileSync(gitignorePath, gitignoreContent);
+        logger.info('[✓] .gitignore populated');
+    }
+    function setDrizzle(name) {
+        const drizzleConfigPath = path.join(root, 'drizzle.config.ts');
+        if (!existsSync(drizzleConfigPath)) {
+            writeFileSync(drizzleConfigPath, templates.drizzleConfig(name.toString()));
+            logger.info('[✓] Drizzle config added');
+            return;
+        }
+        logger.info(templates.regenerateDrizzleConfig(root)
+            ? '[✓] Drizzle config schema path updated'
+            : '[✓] Drizzle config already exists (skip)');
+    }
+    function configureVite() {
+        const configPath = path.resolve(root, 'vite.config.ts');
+        if (!fs.existsSync(configPath)) {
+            throw new Error("Can't find vite configuration file");
+        }
+        let content = fs.readFileSync(configPath, 'utf-8');
+        content = content.replace("from '@sveltejs/adapter-auto'", "from '@sveltejs/adapter-node'");
+        const program = babelParse(content, getLang(configPath));
+        const programBody = program.body;
+        const configObject = findSvelteConfigObject(programBody);
+        if (!configObject) {
+            throw new Error("Couldn't find the Vite config object (defineConfig({...}) or export default {...})");
+        }
+        const pluginsProp = configObject.properties.find((p) => t.isObjectProperty(p) && t.isIdentifier(p.key) && p.key.name === 'plugins');
+        if (!pluginsProp || !t.isArrayExpression(pluginsProp.value)) {
+            throw new Error("Couldn't find a `plugins: [...]` array in the Vite config object");
+        }
+        const pluginsArray = pluginsProp.value;
+        const alreadyPresent = pluginsArray.elements.some((el) => t.isCallExpression(el) && t.isIdentifier(el.callee) && el.callee.name === 'rime');
+        if (alreadyPresent) {
+            logger.info('[✓] Vite plugin already present (skip)');
+            return;
+        }
+        const hasImport = programBody.some((node) => t.isImportDeclaration(node) &&
+            node.source.value === `${PACKAGE}/vite` &&
+            node.specifiers.some((s) => t.isImportSpecifier(s) && t.isIdentifier(s.imported) && s.imported.name === 'rime'));
+        if (!hasImport) {
+            const importDecl = t.importDeclaration([t.importSpecifier(t.identifier('rime'), t.identifier('rime'))], t.stringLiteral(`${PACKAGE}/vite`));
+            programBody.unshift(importDecl);
+        }
+        const rimeCall = t.callExpression(t.identifier('rime'), []);
+        const sveltekitIndex = pluginsArray.elements.findIndex((el) => t.isCallExpression(el) && t.isIdentifier(el.callee) && el.callee.name === 'sveltekit');
+        if (sveltekitIndex !== -1) {
+            pluginsArray.elements.splice(sveltekitIndex + 1, 0, rimeCall);
+        }
+        else {
+            pluginsArray.elements.push(rimeCall);
+        }
+        const file = t.file(program);
+        const { code } = generateCode(file, {}, content);
+        fs.writeFileSync(configPath, code);
+        logger.info('[✓] Vite plugin added');
+    }
+    function findSvelteConfigObject(body) {
+        for (const node of body) {
+            if (t.isExpressionStatement(node) &&
+                t.isCallExpression(node.expression) &&
+                t.isIdentifier(node.expression.callee) &&
+                node.expression.callee.name === 'defineConfig') {
+                const arg = node.expression.arguments[0];
+                if (t.isObjectExpression(arg))
+                    return arg;
+            }
+            if (t.isExportDefaultDeclaration(node)) {
+                const decl = node.declaration;
+                if (t.isCallExpression(decl) &&
+                    t.isIdentifier(decl.callee) &&
+                    decl.callee.name === 'defineConfig') {
+                    const arg = decl.arguments[0];
+                    if (t.isObjectExpression(arg))
+                        return arg;
+                }
+                if (t.isObjectExpression(decl)) {
+                    return decl;
+                }
+            }
+        }
+        return null;
+    }
+    async function copyAssets() {
+        try {
+            const currentDir = path.dirname(fileURLToPath(import.meta.url));
+            await mkdir(path.resolve(process.cwd(), 'static/assets/panel/fonts'), { recursive: true });
+            await cp(path.join(currentDir, '../../../../panel/fonts'), path.resolve(process.cwd(), 'static/assets/panel/fonts'), {
+                recursive: true
+            });
+            logger.info('[✓] Copied assets');
+        }
+        catch (err) {
+            console.error('Error copying fonts:', err);
+        }
+    }
+    if (force || incomingName) {
+        const name = incomingName || packageName;
+        setEnv();
+        addToGitignore();
+        setConfig(name);
+        setDatabase();
+        setDrizzle(name);
+        configureVite();
+        await copyAssets();
+        !skipInstall && installDependencies();
+        await generate({ force: true });
+    }
+    else {
+        let name = '';
+        const defaultName = slugify(packageName);
+        let tries = 0;
+        while (!isValidSlug(name)) {
+            name = await prompt(tries > 0
+                ? 'Error: should contains only letters, numbers, hyphens, underscores\nWhat is your project name (will be used as database name) ?'
+                : 'What is your project name (will be used as database name) ?', defaultName || 'app');
+            tries++;
+        }
+        if (!name) {
+            logger.error('Operation cancelled');
+            process.exit(0);
+        }
+        setEnv();
+        addToGitignore();
+        setConfig(name);
+        setDatabase();
+        setDrizzle(name);
+        configureVite();
+        await copyAssets();
+        !skipInstall && installDependencies();
+        await generate({ force: true });
+        logger.info('[✓] done');
+    }
+};

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

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
-import { logger } from '../../logger/index.server.js';
+import { logger } from '../../logger.server.js';
 import { spawnSync } from 'node:child_process';
 import { program } from 'commander';
 import { existsSync, writeFileSync } from 'fs';
-import { envProduction } from './build/templates.js';
+import { envProduction } from './templates/build.js';
 program.version('0.1').description('CMS utilities');
 program.description('Rime utilities');
 program
@@ -12,7 +12,7 @@ program
     .option('-f, --force', 'Force init with default package name', false)
     .option('-s, --skip-install', 'Do not install dependencies', false)
     .action(async (args) => {
-    const init = await import('./init/index.server.js').then((m) => m.init);
+    const init = await import('./commands/init.server.js').then((m) => m.init);
     init(args);
 });
 program
@@ -21,21 +21,21 @@ program
     .option('-e, --with-env', 'Create the /app/.env file from the production template', false)
     .option('-s, --with-static', 'Copy the current static directory', false)
     .action(async (args) => {
-    const build = await import('./build/index.js').then((m) => m.build);
+    const build = await import('./commands/build.js').then((m) => m.build);
     build(args);
 });
 program
     .command('clear')
     .option('-f, --force', 'Force clear without prompt', false)
     .action(async (args) => {
-    const clear = await import('./clear/index.server.js').then((m) => m.clear);
+    const clear = await import('./commands/clear.server.js').then((m) => m.clear);
     clear(args);
 });
 program
     .command('generate')
     .option('-f, --force', 'Force generation, ignore cache, overwrite routes', false)
     .action(async (args) => {
-    const generate = await import('./generate/index.server.js').then((m) => m.generate);
+    const generate = await import('./commands/generate.server.js').then((m) => m.generate);
     try {
         await generate({
             force: args.force
@@ -47,8 +47,8 @@ program
 });
 program
     .command('package')
-    .description("Builds a rime plugin/field package for publish: svelte-kit sync, svelte-package, then " +
-    'generate-manifest — makes any $rime/modules splits it exports consumable by anyone who ' +
+    .description('Builds a rime plugin/field package for publish: svelte-kit sync, svelte-package, then ' +
+    'generate-exports — makes any $rime/modules: splits it declares resolvable by anyone who ' +
     'installs it. Equivalent to chaining those three yourself.')
     .action(() => {
     const sync = spawnSync('./node_modules/.bin/svelte-kit', ['sync'], { stdio: 'inherit' });
@@ -61,9 +61,9 @@ program
         process.exitCode = build.status ?? 1;
         return;
     }
-    import('./generate-manifest/index.server.js').then(({ generateManifest }) => {
+    import('./commands/generate-exports.server.js').then(({ generateExports }) => {
         try {
-            generateManifest();
+            generateExports();
         }
         catch (error) {
             logger.error(error.message);
@@ -72,14 +72,14 @@ program
     });
 });
 program
-    .command('generate-manifest')
-    .description("Run after svelte-package, before publish — makes this package's own $rime/modules " +
-    'splits consumable by anyone who installs it (rewrites the barrel into qualified ' +
-    'imports in dist/, writes dist/.rime-modules.json + .d.ts).')
+    .command('generate-exports')
+    .description("Run after svelte-package, before publish — makes this package's own $rime/modules: " +
+    'splits resolvable by anyone who installs it (rewrites them to package subpaths in ' +
+    'dist/, writes the matching exports entries into package.json).')
     .action(async () => {
-    const generateManifest = await import('./generate-manifest/index.server.js').then((m) => m.generateManifest);
+    const generateExports = await import('./commands/generate-exports.server.js').then((m) => m.generateExports);
     try {
-        generateManifest();
+        generateExports();
     }
     catch (error) {
         logger.error(error.message);

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

@@ -0,0 +1,45 @@
+import { PANEL_ROUTE } from '../../../routes/constants.server.js';
+import { randomId } from '../../../../util/random.js';
+export const envProduction = () => `# BETTER-AUTH
+BETTER_AUTH_SECRET=${randomId(32)}
+
+# RIME
+PUBLIC_RIME_URL=http://localhost:3000
+RIME_PANEL_ROUTE=${PANEL_ROUTE}
+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 nodeServer = `import { createServer } from 'node:http';
+import serveStatic from 'serve-static';
+import { handler } from './build/handler.js';
+
+const serve = serveStatic('./static');
+
+const port = process.env.PORT || 3000;
+const host = process.env.HOST || '127.0.0.1';
+const protocol = process.env.ORIGIN?.startsWith('https') ? 'https' : 'http';
+
+createServer((req, res) => {
+	serve(req, res, () => handler(req, res, () => {
+		res.statusCode = 404;
+		res.end();
+	}));
+}).listen(port, host, () => {
+	console.log(\`server running on \${protocol}://\${host}:\${port}\`);
+});
+`;

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

@@ -0,0 +1,18 @@
+export declare const env: () => string;
+export declare const defaultConfig: (name: string) => string;
+export declare const drizzleConfig: (name: string) => string;
+export declare const hooks: () => string;
+/** Writes src/hooks.server.ts if missing. If it already exists, patches only the config
+ * import line if it's stale (e.g. after RIME_CONFIG_DIR changes the import path) — the rest
+ * of the file may carry real customizations (e.g. an appended handler), so this never
+ * touches anything else. Called both at `rime init` and whenever the dev server detects a
+ * config change, so the import path never goes stale between the two. Returns whether it
+ * wrote anything. */
+export declare function regenerateHooks(root?: string): boolean;
+/** Patches drizzle.config.ts's schema path line if it's stale (e.g. after RIME_CONFIG_DIR
+ * changes) — only that one line, since the rest of the file may carry real customizations
+ * (verbose, custom fields, etc.). Must run before generateSchema()'s own drizzle-kit
+ * generate/migrate shell-out, which reads this file from disk. No-op if the file doesn't
+ * exist — creating it from scratch needs a project name, which is `rime init`'s job
+ * (setDrizzle() in init/index.server.ts). Returns whether it patched anything. */
+export declare function regenerateDrizzleConfig(root?: string): boolean;

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

@@ -0,0 +1,117 @@
+import { PANEL_ROUTE } from '../../../routes/constants.server.js';
+import { randomId } from '../../../../util/random.js';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import { CONFIG_DIR, GENERATED_DIR, configImportPaths } from '../../constants.server.js';
+const PACKAGE = 'rimecms';
+export const env = () => `BETTER_AUTH_SECRET=${randomId(32)}
+PUBLIC_RIME_URL=http://localhost:5173
+RIME_CONFIG_DIR=${CONFIG_DIR}
+
+# Panel URL segment (e.g. /panel/...). Change it to hide the panel from
+# automated CMS-admin scanners — requests to the old segment 404 instead of
+# revealing a login page. Run 'rime generate' (or restart 'rime dev') after
+# changing this — the dev server only regenerates routes when it detects a
+# change under RIME_CONFIG_DIR, not on every restart.
+RIME_PANEL_ROUTE=${PANEL_ROUTE}
+
+# RIME_CACHE_ENABLED=false
+# RIME_SMTP_USER=user@mail.com
+# RIME_SMTP_PASSWORD=supersecret
+# RIME_SMTP_HOST=smtphost.com
+# RIME_SMTP_PORT=465
+
+RIME_CACHE_ENABLED=false
+RIME_LOG_LEVEL=TRACE
+RIME_LOG_TO_FILE=true
+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}/adapter-sqlite';
+
+const Pages = Collection.create('pages', {
+	fields: [text('title').isTitle()]
+});
+
+const Medias = Collection.create('medias', {
+  upload: true,
+	fields: [
+    text('alt').required(),
+  ]
+});
+
+export default rime({
+  $adapter: adapterSqlite('${name}.sqlite'),
+  collections: [Pages, Medias]
+});
+`;
+export const drizzleConfig = (name) => `
+import { defineConfig, type Config } from 'drizzle-kit';
+
+export const config: Config = {
+  schema: './${GENERATED_DIR}/schema.server.ts',
+  out: './db',
+  strict: false,
+  dialect: 'sqlite',
+  dbCredentials: {
+    url: './db/${name}.sqlite'
+  }
+};
+
+export default defineConfig(config);
+`;
+// Regenerated fresh by rime init every time (setHooks() only skips if the file already
+// exists, and `rime clear`/useConfig.js delete it first) — safe to make mode-aware.
+const HOOKS_DIR = path.resolve(process.cwd(), 'src');
+export const hooks = () => `import { sequence } from '@sveltejs/kit/hooks';
+import { handlers } from '${PACKAGE}/server';
+import config from '${configImportPaths(HOOKS_DIR).server}';
+
+export const handle = sequence(...(await handlers(config)));
+`;
+const HOOKS_CONFIG_IMPORT_LINE_REGEX = /^import config from ['"][^'"]*['"];\s*$/m;
+/** Writes src/hooks.server.ts if missing. If it already exists, patches only the config
+ * import line if it's stale (e.g. after RIME_CONFIG_DIR changes the import path) — the rest
+ * of the file may carry real customizations (e.g. an appended handler), so this never
+ * touches anything else. Called both at `rime init` and whenever the dev server detects a
+ * config change, so the import path never goes stale between the two. Returns whether it
+ * wrote anything. */
+export function regenerateHooks(root = process.cwd()) {
+    const hooksPath = path.join(root, 'src', 'hooks.server.ts');
+    const srcDir = path.join(root, 'src');
+    if (!existsSync(hooksPath)) {
+        if (!existsSync(srcDir)) {
+            mkdirSync(srcDir, { recursive: true });
+        }
+        writeFileSync(hooksPath, hooks(), 'utf-8');
+        return true;
+    }
+    const expectedImportLine = `import config from '${configImportPaths(HOOKS_DIR).server}';`;
+    const content = readFileSync(hooksPath, 'utf-8');
+    if (HOOKS_CONFIG_IMPORT_LINE_REGEX.test(content) && !content.includes(expectedImportLine)) {
+        writeFileSync(hooksPath, content.replace(HOOKS_CONFIG_IMPORT_LINE_REGEX, expectedImportLine));
+        return true;
+    }
+    return false;
+}
+const DRIZZLE_SCHEMA_LINE_REGEX = /^\s*schema:\s*['"][^'"]*['"],?\s*$/m;
+/** Patches drizzle.config.ts's schema path line if it's stale (e.g. after RIME_CONFIG_DIR
+ * changes) — only that one line, since the rest of the file may carry real customizations
+ * (verbose, custom fields, etc.). Must run before generateSchema()'s own drizzle-kit
+ * generate/migrate shell-out, which reads this file from disk. No-op if the file doesn't
+ * exist — creating it from scratch needs a project name, which is `rime init`'s job
+ * (setDrizzle() in init/index.server.ts). Returns whether it patched anything. */
+export function regenerateDrizzleConfig(root = process.cwd()) {
+    const drizzleConfigPath = path.join(root, 'drizzle.config.ts');
+    if (!existsSync(drizzleConfigPath))
+        return false;
+    const expectedSchemaLine = `  schema: './${GENERATED_DIR}/schema.server.ts',`;
+    const content = readFileSync(drizzleConfigPath, 'utf-8');
+    if (DRIZZLE_SCHEMA_LINE_REGEX.test(content) && !content.includes(expectedSchemaLine)) {
+        writeFileSync(drizzleConfigPath, content.replace(DRIZZLE_SCHEMA_LINE_REGEX, expectedSchemaLine));
+        return true;
+    }
+    return false;
+}

package/dist/core/dev/cli/util/package-manager.server.js

@@ -1,4 +1,4 @@
-import { logger } from '../../../logger/index.server.js';
+import { logger } from '../../../logger.server.js';
 import { execSync } from 'child_process';
 import { existsSync } from 'fs';
 import path from 'path';
@@ -9,8 +9,12 @@ const packageManagersMap = {
     npm: 'package-lock.json',
     deno: 'deno.lock'
 };
-const deps = ['drizzle-orm', '@libsql/client', '@lucide/svelte', 'sharp'];
-const devDeps = ['@sveltejs/adapter-node', 'drizzle-kit'];
+// Drizzle is pinned to the exact release rime is built against. `@rc` is a moving tag and a
+// prerelease range drifts across API changes — an app on a different rc than the rimecms it
+// installed is the split that made every sign-in fail when better-auth did the same thing.
+const DRIZZLE = '1.0.0-rc.4';
+const deps = [`drizzle-orm@${DRIZZLE}`, '@libsql/client', '@lucide/svelte', 'sharp'];
+const devDeps = ['@sveltejs/adapter-node', `drizzle-kit@${DRIZZLE}`];
 const packageManagerConfigs = {
     yarn: {
         command: 'echo "yarn is not supported, please use pnpm or npm" && exit 1'

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

@@ -1,9 +1 @@
-/**
- * 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/util/package.server.js

@@ -1,15 +1,5 @@
 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