@fecommunity/reactpress 4.0.0-beta.1 → 4.0.0-beta.10

package/out/lib/docker.js

@@ -141,6 +141,18 @@ async function startDockerServices(projectRoot) {
     console.log(t('docker.started'));
 }
 async function ensureDevDatabase(projectRoot, { quiet = false } = {}) {
+    const { isLocalSqliteMode } = require('./database-mode');
+    if (isLocalSqliteMode(projectRoot)) {
+        const { ensureSqliteDatabase } = require('../core/services/database/sqlite');
+        const { syncEnvFromConfig, loadConfig } = require('../core/services/config');
+        const config = await loadConfig(projectRoot);
+        await syncEnvFromConfig(projectRoot, config);
+        const result = await ensureSqliteDatabase(projectRoot);
+        if (!result.ok) {
+            throw new Error(result.message || 'SQLite 数据库未就绪');
+        }
+        return;
+    }
     const dbPort = parseDbPort(projectRoot);
     const ctx = resolveComposeContext(projectRoot);
     const container = resolveDbContainerName(ctx, projectRoot);

package/out/lib/doctor.js

@@ -7,10 +7,11 @@ const path = require('path');
 const { execSync } = require('child_process');
 const ora = require('ora');
 const { brand, icon, ok, warn, divider, sectionHeader, terminalWidth, gradientText, palette, } = require('../ui/theme');
-const { getHealthUrl, checkHealth } = require('./http');
+const { getHealthUrl, checkHealth, loadAdminConsoleUrl, loadClientSiteUrl, isHttpResponding, } = require('./http');
 const { isDockerRunning } = require('./docker');
 const { checkNginx } = require('./nginx');
 const { envFileStatus } = require('./status');
+const { describeProject } = require('./project-type');
 const { t } = require('./i18n');
 function checkNodeVersion() {
     const major = parseInt(process.versions.node.split('.')[0], 10);
@@ -33,6 +34,74 @@ function checkDocker() {
         fix: t('doctor.dockerFix'),
     };
 }
+function isLocalZeroDepMode(projectRoot) {
+    if (process.env.REACTPRESS_LOCAL_MODE === '1' || process.env.REACTPRESS_SKIP_NGINX === '1') {
+        return true;
+    }
+    const env = parseEnv(projectRoot);
+    if (String(env.DB_TYPE || '').toLowerCase() === 'sqlite')
+        return true;
+    try {
+        const configPath = path.join(projectRoot, '.reactpress', 'config.json');
+        if (fs.existsSync(configPath)) {
+            const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+            if (config.database?.mode === 'embedded-sqlite')
+                return true;
+        }
+    }
+    catch {
+        // ignore
+    }
+    return false;
+}
+async function resolveProjectProfile(projectRoot) {
+    const env = parseEnv(projectRoot);
+    let configMode;
+    try {
+        const configPath = path.join(projectRoot, '.reactpress', 'config.json');
+        if (fs.existsSync(configPath)) {
+            const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+            configMode = config.database?.mode;
+        }
+    }
+    catch {
+        // ignore
+    }
+    const envDbType = String(env.DB_TYPE || '').toLowerCase();
+    if (process.env.REACTPRESS_LOCAL_MODE === '1' ||
+        process.env.REACTPRESS_SKIP_NGINX === '1' ||
+        envDbType === 'sqlite' ||
+        configMode === 'embedded-sqlite') {
+        return { localMode: true, dbType: 'sqlite', requiresDocker: false };
+    }
+    const dbType = await resolveDbType(projectRoot);
+    if (dbType === 'sqlite') {
+        return { localMode: true, dbType: 'sqlite', requiresDocker: false };
+    }
+    if (configMode === 'embedded-docker') {
+        return { localMode: false, dbType: 'mysql', requiresDocker: true };
+    }
+    return { localMode: false, dbType, requiresDocker: true };
+}
+function applyProjectRuntimeEnv(profile) {
+    if (profile.localMode) {
+        process.env.REACTPRESS_LOCAL_MODE = '1';
+        process.env.REACTPRESS_SKIP_NGINX = '1';
+    }
+}
+function checkDockerForProject(projectRoot, profile) {
+    if (profile?.requiresDocker === false || profile?.localMode || isLocalZeroDepMode(projectRoot)) {
+        return { ok: true, message: t('doctor.dockerSkipped') };
+    }
+    return checkDocker();
+}
+function checkPnpmForProject(projectRoot) {
+    const project = describeProject(projectRoot);
+    if (project.kind !== 'monorepo') {
+        return { ok: true, message: t('doctor.pnpmSkipped') };
+    }
+    return checkPnpm();
+}
 function parseEnv(projectRoot) {
     const envPath = path.join(projectRoot, '.env');
     const out = {};
@@ -92,9 +161,25 @@ async function checkPorts(projectRoot) {
         message: t('doctor.portOk', { apiPort, clientPort }),
     };
 }
-async function checkDatabase(projectRoot) {
+async function resolveDbType(projectRoot) {
     const env = parseEnv(projectRoot);
-    const dbType = String(env.DB_TYPE || 'mysql').toLowerCase();
+    if (String(env.DB_TYPE || '').toLowerCase() === 'sqlite')
+        return 'sqlite';
+    try {
+        const configPath = path.join(projectRoot, '.reactpress', 'config.json');
+        if (fs.existsSync(configPath)) {
+            const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+            if (config.database?.mode === 'embedded-sqlite')
+                return 'sqlite';
+        }
+    }
+    catch {
+        // ignore
+    }
+    return 'mysql';
+}
+async function checkDatabase(projectRoot) {
+    const dbType = await resolveDbType(projectRoot);
     if (dbType === 'sqlite') {
         const { probeSqliteDatabase } = require('../core/services/database/sqlite');
         const result = await probeSqliteDatabase(projectRoot);
@@ -106,6 +191,7 @@ async function checkDatabase(projectRoot) {
             fix: result.ok ? undefined : t('doctor.dbSqliteFix'),
         };
     }
+    const env = parseEnv(projectRoot);
     const host = env.DB_HOST || '127.0.0.1';
     const port = parseInt(env.DB_PORT || '3306', 10);
     const user = env.DB_USER || 'root';
@@ -148,16 +234,43 @@ async function checkDatabase(projectRoot) {
         });
     });
 }
-async function checkApiHealth(projectRoot) {
+async function checkApiHealth(projectRoot, profile) {
     const healthUrl = getHealthUrl(projectRoot);
     const result = await checkHealth(healthUrl);
     if (result.ok) {
         return { ok: true, message: t('doctor.apiOk', { url: healthUrl }) };
     }
+    const fix = profile?.localMode || isLocalZeroDepMode(projectRoot)
+        ? t('doctor.apiFixInit')
+        : t('doctor.apiFix');
     return {
         ok: false,
         message: t('doctor.apiBad', { url: healthUrl }),
-        fix: t('doctor.apiFix'),
+        fix,
+    };
+}
+async function checkThemeSite(projectRoot) {
+    const url = loadClientSiteUrl(projectRoot);
+    const ok = await isHttpResponding(url, 2500);
+    if (ok) {
+        return { ok: true, message: t('doctor.siteOk', { url }) };
+    }
+    return {
+        ok: false,
+        message: t('doctor.siteBad', { url }),
+        fix: t('doctor.siteFix'),
+    };
+}
+async function checkAdminConsole(projectRoot) {
+    const url = loadAdminConsoleUrl(projectRoot);
+    const ok = await isHttpResponding(url, 2500);
+    if (ok) {
+        return { ok: true, message: t('doctor.adminOk', { url }) };
+    }
+    return {
+        ok: false,
+        message: t('doctor.adminBad', { url }),
+        fix: t('doctor.adminFix', { url }),
     };
 }
 function checkPnpm() {
@@ -189,16 +302,18 @@ async function runCheckWithSpinner(name, run) {
     return result;
 }
 async function runDoctor(projectRoot) {
+    const profile = await resolveProjectProfile(projectRoot);
+    applyProjectRuntimeEnv(profile);
     const env = envFileStatus(projectRoot);
     const checks = [
         { name: 'Node.js', run: () => checkNodeVersion() },
-        { name: 'pnpm', run: () => checkPnpm() },
+        { name: 'pnpm', run: () => checkPnpmForProject(projectRoot) },
         {
             name: t('doctor.check.config'),
             run: () => ({
                 ok: env.config,
                 message: env.config ? t('doctor.configOk') : t('doctor.configBad'),
-                fix: t('doctor.configFix'),
+                fix: env.config ? undefined : t('doctor.configFix'),
             }),
         },
         {
@@ -206,15 +321,18 @@ async function runDoctor(projectRoot) {
             run: () => ({
                 ok: env.env,
                 message: env.env ? t('doctor.envOk') : t('doctor.envBad'),
-                fix: t('doctor.envFix'),
+                fix: env.env ? undefined : t('doctor.envFix'),
             }),
         },
-        { name: 'Docker', run: () => checkDocker() },
+        { name: 'Docker', run: () => checkDockerForProject(projectRoot, profile) },
         { name: t('doctor.check.nginx'), run: () => checkNginx(projectRoot) },
         { name: t('doctor.check.ports'), run: () => checkPorts(projectRoot) },
         { name: t('doctor.check.database'), run: () => checkDatabase(projectRoot) },
-        { name: t('doctor.check.api'), run: () => checkApiHealth(projectRoot) },
+        { name: t('doctor.check.api'), run: () => checkApiHealth(projectRoot, profile) },
     ];
+    if (profile.localMode) {
+        checks.push({ name: t('doctor.check.site'), run: () => checkThemeSite(projectRoot) }, { name: t('doctor.check.admin'), run: () => checkAdminConsole(projectRoot) });
+    }
     const w = Math.min(terminalWidth() - 4, 52);
     const results = [];
     const fixes = [];
@@ -256,5 +374,8 @@ module.exports = {
     runDoctor,
     checkNodeVersion,
     checkDocker,
+    checkDockerForProject,
+    resolveProjectProfile,
+    isLocalZeroDepMode,
 };
 //# sourceMappingURL=doctor.js.map

package/out/lib/http.js

@@ -41,6 +41,25 @@ function loadWebAdminUrl(projectRoot) {
     }
     return `http://localhost:${DEV_PORTS.ADMIN_WEB}`;
 }
+/** Admin console URL for the running stack (Vite dev vs theme-embedded SPA). */
+function loadAdminConsoleUrl(projectRoot) {
+    const envPath = path.join(projectRoot, '.env');
+    try {
+        const content = fs.readFileSync(envPath, 'utf8');
+        const urlMatch = content.match(/^WEB_ADMIN_URL=(.+)$/m);
+        if (urlMatch) {
+            return urlMatch[1].trim().replace(/^['"]|['"]$/g, '');
+        }
+    }
+    catch {
+        // ignore
+    }
+    if (process.env.REACTPRESS_LOCAL_MODE === '1' || process.env.REACTPRESS_SKIP_NGINX === '1') {
+        const client = loadClientSiteUrl(projectRoot).replace(/\/$/, '');
+        return `${client}/admin/`;
+    }
+    return loadWebAdminUrl(projectRoot);
+}
 function loadClientSiteUrl(projectRoot) {
     const envPath = path.join(projectRoot, '.env');
     try {
@@ -220,6 +239,7 @@ module.exports = {
     isHealthPayloadReady,
     loadServerSiteUrl,
     loadWebAdminUrl,
+    loadAdminConsoleUrl,
     loadClientSiteUrl,
     getApiPrefix,
     getHealthUrl,

package/out/lib/i18n/index.js

@@ -14,8 +14,12 @@ let locale = resolveLocale();
 function t(key, vars = {}) {
     const table = STRINGS[locale] || STRINGS.en;
     let text = table[key] ?? STRINGS.en[key] ?? key;
+    if (text == null) {
+        text = key == null ? '' : String(key);
+    }
+    text = String(text);
     for (const [name, value] of Object.entries(vars)) {
-        text = text.replace(new RegExp(`\\{${name}\\}`, 'g'), String(value));
+        text = text.replace(new RegExp(`\\{${name}\\}`, 'g'), String(value ?? ''));
     }
     return text;
 }