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

package/out/lib/dev.js

@@ -25,6 +25,7 @@ const { acquireDevSession, releaseDevSession } = require('./dev-session');
 const { checkNodeVersion, checkDocker } = require('./doctor');
 const { startDevTimer, markDevPhase, isDevVerbose, logDevLine, logDevDetail, logDevStatus, logDevTimingSummary, } = require('./dev-log');
 const { t } = require('./i18n');
+const { isDesktopLocalMode, isLocalSqliteMode } = require('./database-mode');
 const { resolveRemoteThemeApiBase, readDevClientApiOrigin, normalizeRemoteOrigin, } = require('./remote-dev');
 const CLIENT_READY_TIMEOUT_MS = 120_000;
 const API_READY_TIMEOUT_MS = 180_000;
@@ -39,13 +40,35 @@ function logDevPhase(step, total, messageKey, vars = {}) {
     console.log('');
     console.log(`[reactpress] [${step}/${total}] ${t(messageKey, vars)}`);
 }
-function isDesktopLocalMode() {
-    return process.env.REACTPRESS_DESKTOP_LOCAL === '1';
-}
-function isLocalSqliteMode() {
-    return process.env.REACTPRESS_LOCAL_MODE === '1' || isDesktopLocalMode();
+async function applyAutoLocalDevFallback(projectRoot, { needsLocalApi = true } = {}) {
+    if (!needsLocalApi)
+        return false;
+    if (isLocalSqliteMode(projectRoot)) {
+        process.env.REACTPRESS_SKIP_NGINX = '1';
+        return false;
+    }
+    if (process.env.REACTPRESS_FORCE_MYSQL === '1')
+        return false;
+    const docker = checkDocker();
+    const mysqlOk = docker.ok ? await probeMysqlHost(projectRoot) : false;
+    if (docker.ok && mysqlOk)
+        return false;
+    process.env.REACTPRESS_LOCAL_MODE = '1';
+    process.env.REACTPRESS_SKIP_NGINX = '1';
+    console.log('');
+    console.log(`[reactpress] ${t(docker.ok ? 'dev.autoLocalNoMysql' : 'dev.autoLocalNoDocker')}`);
+    return true;
 }
 function desktopPhaseKey(defaultKey) {
+    if (isLocalSqliteMode()) {
+        const localMap = {
+            'dev.phasePrerequisites': 'dev.phasePrerequisitesDesktop',
+            'dev.phaseInfra': 'dev.phaseInfraDesktop',
+            'dev.phaseServices': 'dev.phaseServicesLocalWeb',
+        };
+        if (localMap[defaultKey])
+            return localMap[defaultKey];
+    }
     if (!isDesktopLocalMode())
         return defaultKey;
     const map = {
@@ -254,7 +277,7 @@ async function spawnAdminWeb(projectRoot, { behindNginx = false, integratedStack
             adminEnv.VITE_DEV_API_PROXY_TARGET = normalizeRemoteOrigin(adminApiOrigin) || adminApiOrigin;
         }
         else if (isDesktopLocalMode() && process.env.REACTPRESS_DESKTOP_LOCAL_API) {
-            // Desktop dev embeds SQLite API on a dedicated port (default :13102), not :3002.
+            // Local SQLite API uses the same port as SERVER_PORT (default :3002).
             adminEnv.VITE_DEV_API_PROXY_TARGET = process.env.REACTPRESS_DESKTOP_LOCAL_API.replace(/\/api\/?$/, '');
         }
         else {
@@ -308,21 +331,28 @@ function assertDevPrerequisites() {
             process.exit(1);
         }
     }
-    logDevStatus(isDesktopLocalMode() ? 'dev.prerequisitesOkDesktop' : 'dev.prerequisitesOk', { version: process.version });
+    logDevStatus(isDesktopLocalMode() || process.env.REACTPRESS_LOCAL_MODE === '1'
+        ? 'dev.prerequisitesOkDesktop'
+        : 'dev.prerequisitesOk', { version: process.version });
 }
 async function prepareDevInfrastructure(projectRoot, { needsLocalApi = true } = {}) {
     await acquireDevSession(projectRoot);
-    if (isLocalSqliteMode()) {
+    if (isLocalSqliteMode(projectRoot)) {
+        const { ensureLocalSite } = require('../core/services/local-site');
+        const { ensureSqliteDatabase } = require('../core/services/database/sqlite');
+        const { syncEnvFromConfig, loadConfig } = require('../core/services/config');
+        const { getMonorepoRoot } = require('./root');
+        const port = readEnvPort(projectRoot, 'SERVER_PORT', DEV_PORTS.API);
         if (process.env.REACTPRESS_LOCAL_MODE === '1') {
-            const { ensureLocalSite } = require('../core/services/local-site');
-            const { ensureSqliteDatabase } = require('../core/services/database/sqlite');
-            const { getMonorepoRoot } = require('./root');
-            const port = readEnvPort(projectRoot, 'SERVER_PORT', DEV_PORTS.API);
             ensureLocalSite(projectRoot, port, { monorepoRoot: getMonorepoRoot() });
-            const sqliteResult = await ensureSqliteDatabase(projectRoot);
-            if (!sqliteResult.ok) {
-                throw new Error(sqliteResult.message || 'SQLite 数据库未就绪');
-            }
+        }
+        else {
+            const config = await loadConfig(projectRoot);
+            await syncEnvFromConfig(projectRoot, config);
+        }
+        const sqliteResult = await ensureSqliteDatabase(projectRoot);
+        if (!sqliteResult.ok) {
+            throw new Error(sqliteResult.message || 'SQLite 数据库未就绪');
         }
         nginxEnabled = false;
         delete process.env.REACTPRESS_NGINX_ENTRY_URL;
@@ -369,7 +399,9 @@ async function startDevStack(projectRoot, { webOnly = false, themeOnly = false,
             process.exit(1);
         }
     }
-    else if (needsLocalApi && !(await probeMysqlHost(projectRoot))) {
+    else if (needsLocalApi &&
+        !isLocalSqliteMode(projectRoot) &&
+        !(await probeMysqlHost(projectRoot))) {
         console.error(t('dev.dbEnsureFailed', {
             message: t('docker.devStartBlocked', {
                 port: readEnvPort(projectRoot, 'DB_PORT', DEV_PORTS.MYSQL),
@@ -531,7 +563,7 @@ async function startDevStack(projectRoot, { webOnly = false, themeOnly = false,
             themeWait.then((ready) => {
                 if (ready)
                     logDevDetail('dev.themeReadyQuiet', { url: loadClientSiteUrl(projectRoot) });
-            });
+            }).catch(() => { });
         }
     }
     if (readinessWaits.length > 1) {
@@ -557,12 +589,17 @@ async function startDevStack(projectRoot, { webOnly = false, themeOnly = false,
             }
         });
     }
-    const dbOk = isDesktopLocalMode()
-        ? true
-        : needsLocalApi
-            ? await probeMysqlHost(projectRoot)
-            : true;
-    if (needsLocalApi && !dbOk && !isDesktopLocalMode()) {
+    let dbOk = true;
+    if (needsLocalApi) {
+        if (isDesktopLocalMode() || isLocalSqliteMode(projectRoot)) {
+            const { probeSqliteDatabase } = require('../core/services/database/sqlite');
+            dbOk = (await probeSqliteDatabase(projectRoot)).ok;
+        }
+        else {
+            dbOk = await probeMysqlHost(projectRoot);
+        }
+    }
+    if (needsLocalApi && !dbOk && !isDesktopLocalMode() && !isLocalSqliteMode(projectRoot)) {
         console.warn(t('dev.mysqlUnreachable'));
     }
     if (includeThemeSite && process.env.REACTPRESS_SKIP_PREVIEW_BUILD !== '1' && !prewarmPreviewBuilds) {
@@ -579,7 +616,11 @@ async function startDevStack(projectRoot, { webOnly = false, themeOnly = false,
         adminApiOrigin,
         clientApiOrigin,
         localApiUrl: isDesktopLocalMode() ? process.env.REACTPRESS_DESKTOP_LOCAL_API || null : null,
-        dbType: isDesktopLocalMode() ? 'sqlite' : needsLocalApi ? 'mysql' : null,
+        dbType: isDesktopLocalMode() || isLocalSqliteMode(projectRoot)
+            ? 'sqlite'
+            : needsLocalApi
+                ? 'mysql'
+                : null,
     });
     logDevTimingSummary({
         apiReused: Boolean(apiSpawn?.reused),
@@ -598,6 +639,7 @@ async function runDevStartup(projectRoot, { webOnly = false, themeOnly = false,
         console.error(formatDevFailureHint());
         process.exit(1);
     }
+    await applyAutoLocalDevFallback(projectRoot, { needsLocalApi: apiOrigins.needsLocalApi });
     logDevPhase(1, 3, desktopPhaseKey('dev.phasePrerequisites'));
     assertDevPrerequisites();
     logDevPhase(2, 3, desktopPhaseKey('dev.phaseInfra'));
@@ -623,22 +665,8 @@ async function runDevStartup(projectRoot, { webOnly = false, themeOnly = false,
         apiOrigins,
     });
 }
-function ensureDesktopBuilt(projectRoot) {
-    const localServerJs = path.join(projectRoot, 'desktop/out/main/local-server.js');
-    if (fs.existsSync(localServerJs))
-        return;
-    const buildResult = spawnSync('pnpm', ['run', '--dir', './desktop', 'build'], {
-        cwd: projectRoot,
-        shell: true,
-        stdio: 'inherit',
-        env: {
-            ...process.env,
-            REACTPRESS_ORIGINAL_CWD: projectRoot,
-        },
-    });
-    if (buildResult.status !== 0) {
-        process.exit(buildResult.status ?? 1);
-    }
+function loadDesktopBootstrap(projectRoot) {
+    return require(path.join(projectRoot, 'desktop/scripts/bootstrap-local-api.cjs'));
 }
 async function startDesktopLocalApi(projectRoot, { forceRestart = false } = {}) {
     const desktopDir = path.join(projectRoot, 'desktop');
@@ -646,32 +674,21 @@ async function startDesktopLocalApi(projectRoot, { forceRestart = false } = {})
         console.error(`[reactpress] ${t('dev.desktopMissing')}`);
         process.exit(1);
     }
-    ensureDesktopBuilt(projectRoot);
-    const localServerPath = path.join(projectRoot, 'desktop/out/main/local-server.js');
-    const { startLocalServer, resolveDevSiteRoot, getLocalApiBaseUrl, stopLocalServer, DEFAULT_LOCAL_API_PORT, } = require(localServerPath);
-    if (forceRestart) {
-        try {
-            stopLocalServer();
-        }
-        catch {
-            // ignore
-        }
-        const { killPortListeners, isPortListening } = require('./ports');
-        const localApiPort = DEFAULT_LOCAL_API_PORT || 13102;
-        if (isPortListening(localApiPort)) {
-            killPortListeners(localApiPort, 'TERM');
-            await new Promise((r) => setTimeout(r, 400));
-            if (isPortListening(localApiPort)) {
-                killPortListeners(localApiPort, 'KILL');
-                await new Promise((r) => setTimeout(r, 200));
-            }
-        }
-    }
+    const { resolveDevStackPorts, applyDevStackPortsToEnv, resolveApiPortForBind, } = require('./ports');
+    let stack = resolveDevStackPorts(projectRoot);
+    applyDevStackPortsToEnv(stack);
+    const boot = await loadDesktopBootstrap(projectRoot);
     console.log('');
     logDevStatus('dev.desktopLocalApiStarting');
-    const siteRoot = resolveDevSiteRoot(projectRoot);
-    await startLocalServer({ siteRoot, monorepoRoot: projectRoot, forceRestart });
-    const localApiBase = getLocalApiBaseUrl();
+    const resolved = await resolveApiPortForBind(projectRoot, { preferred: stack.api });
+    if (resolved.shifted || resolved.port !== stack.api) {
+        stack = { ...stack, api: resolved.port };
+        applyDevStackPortsToEnv(stack);
+    }
+    const { siteRoot, localApiBase } = await boot.startDesktopLocalApi(projectRoot, {
+        forceRestart,
+        port: resolved.port,
+    });
     process.env.REACTPRESS_DESKTOP_LOCAL_API = localApiBase;
     process.env.REACTPRESS_DESKTOP_SITE_ROOT = siteRoot;
     process.env.REACTPRESS_THEME_API_URL = localApiBase;
@@ -761,7 +778,8 @@ async function spawnDesktopApp(projectRoot) {
     }
     const adminUrl = loadWebAdminUrl(projectRoot).replace(/\/$/, '');
     logDevStatus('dev.desktopStarting', { url: adminUrl });
-    ensureDesktopBuilt(projectRoot);
+    const boot = await loadDesktopBootstrap(projectRoot);
+    boot.ensureDesktopBuilt(projectRoot);
     desktopChild = spawnDevChild('pnpm', ['exec', 'cross-env', `VITE_DEV_SERVER_URL=${adminUrl}`, 'ELECTRON_IS_DEV=1', 'pnpm', 'run', 'dev:shell'], {
         shell: true,
         cwd: desktopDir,
@@ -776,6 +794,37 @@ async function spawnDesktopApp(projectRoot) {
         handlePrimaryDevChildClose(code, 'Desktop shell');
     });
 }
+async function runLocalMonorepoDev(projectRoot = ensureOriginalCwd()) {
+    if (!hasWeb(projectRoot)) {
+        console.error(t('dev.noWeb'));
+        process.exit(1);
+    }
+    process.env.REACTPRESS_SKIP_NGINX = '1';
+    process.env.REACTPRESS_DESKTOP_LOCAL = '1';
+    registerDevShutdownHandlers(projectRoot);
+    console.log('');
+    logDevLine('dev.localFullIntro');
+    await prepareDevInfrastructure(projectRoot, { needsLocalApi: false });
+    await startDesktopLocalApi(projectRoot, { forceRestart: true });
+    await runDevStartup(projectRoot, {
+        skipPrepareInfra: true,
+        apiOrigins: { admin: null, client: null, needsLocalApi: false },
+    });
+    await ensureDesktopLocalApiHealthy(projectRoot);
+    await new Promise((resolve) => {
+        const interval = setInterval(() => {
+            void ensureDesktopLocalApiHealthy(projectRoot).catch(() => { });
+        }, 20_000);
+        const onStop = (signal) => {
+            clearInterval(interval);
+            shutdown(signal);
+            resolve(0);
+        };
+        process.once('SIGINT', () => onStop('SIGINT'));
+        process.once('SIGTERM', () => onStop('SIGTERM'));
+    });
+    process.exit(0);
+}
 async function runDesktopDev(projectRoot = ensureOriginalCwd()) {
     if (!hasWeb(projectRoot)) {
         console.error(t('dev.noWeb'));
@@ -893,11 +942,13 @@ module.exports = {
     runDev,
     runWebDev,
     runLocalWebDev,
+    runLocalMonorepoDev,
     runThemeDev,
     runDesktopDev,
     runDevStartup,
     buildToolkit,
     assertDevPrerequisites,
+    applyAutoLocalDevFallback,
     prepareDevInfrastructure,
     startDevStack,
     detectProjectType,

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;
 }