alemonjs 2.1.83 → 2.1.85

package/lib/{server → application/runtime/http}/routers/router.js

@@ -2,15 +2,22 @@ import KoaRouter from 'koa-router';
 import fs__default, { existsSync } from 'fs';
 import path__default, { join, dirname } from 'path';
 import mime from 'mime-types';
-import hello from './hello.html.js';
+import { renderHelloHtml } from './hello.html.js';
 import { safePath, getModuelFile, formatPath, isValidPackageName } from './utils.js';
 import { collectMiddlewares, runMiddlewares } from './middleware.js';
 import module$1 from 'module';
-import { ResultCode } from '../../core/variable.js';
 import 'yaml';
-import '../../core/utils.js';
-import { listRuntimeApps, getRuntimeApp, toRuntimeAppSnapshot, listRuntimeAppKoaRouters, hasRuntimeAppCapability, getRuntimeAppKoaRouters } from '../../app/store.js';
-import { dispatchHttpError } from '../../app/lifecycle-callbacks.js';
+import '../../../../common/logger.js';
+import { ResultCode } from '../../../../common/variable.js';
+import '../../../../common/utils.js';
+import 'net';
+import 'v8';
+import 'os';
+import 'flatted';
+import '../../../../common/cbp/runtime.js';
+import 'ws';
+import { listRuntimeApps, getRuntimeApp, toRuntimeAppSnapshot, listRuntimeAppKoaRouters, hasRuntimeAppCapability, getChildrenApp, getRuntimeAppKoaRouters } from '../../store.js';
+import { dispatchHttpError } from '../../lifecycle-callbacks.js';
 
 const initRequire = () => { };
 initRequire.resolve = () => '';
@@ -31,14 +38,61 @@ const resolvePackageRoot = (startDir) => {
 const readWebRootConfig = (packageRoot) => {
     const packageJsonPath = path__default.join(packageRoot, 'package.json');
     if (!existsSync(packageJsonPath)) {
+        if (existsSync(path__default.join(packageRoot, 'dist', 'index.html'))) {
+            return 'dist';
+        }
         return '';
     }
     const pkg = require$1(packageJsonPath) ?? {};
-    return pkg?.alemonjs?.web?.root ?? '';
+    const configuredRoot = pkg?.alemonjs?.web?.root ?? '';
+    if (typeof configuredRoot === 'string' && configuredRoot.trim()) {
+        return configuredRoot;
+    }
+    if (existsSync(path__default.join(packageRoot, 'dist', 'index.html'))) {
+        return 'dist';
+    }
+    return '';
+};
+const matchBasePath = (requestPath, basePath) => {
+    if (!basePath) {
+        return requestPath;
+    }
+    if (requestPath === basePath) {
+        return '/';
+    }
+    if (requestPath.startsWith(`${basePath}/`)) {
+        return requestPath.slice(basePath.length) || '/';
+    }
+    return '';
+};
+const matchApiBasePath = (requestPath, basePath) => {
+    return requestPath === basePath || requestPath.startsWith(`${basePath}/`);
+};
+const needsTrailingSlashRedirect = (requestUrl, basePath) => {
+    return requestUrl === basePath || requestUrl.startsWith(`${basePath}?`);
+};
+const getOriginalPathname = (ctx) => {
+    const rawUrl = typeof ctx.originalUrl === 'string' && ctx.originalUrl ? ctx.originalUrl : ctx.url;
+    const [pathname] = String(rawUrl).split('?');
+    return pathname || '/';
+};
+const rewriteCtxPath = async (ctx, nextPath, handler) => {
+    const search = ctx.querystring ? `?${ctx.querystring}` : '';
+    const originalUrl = ctx.url;
+    const originalReqUrl = ctx.req.url;
+    ctx.url = `${nextPath}${search}`;
+    ctx.req.url = `${nextPath}${search}`;
+    try {
+        await handler();
+    }
+    finally {
+        ctx.url = originalUrl;
+        ctx.req.url = originalReqUrl;
+    }
 };
 const denyRuntimeAppAccess = (ctx, appName, capability) => {
     const runtimeApp = getRuntimeApp(appName);
-    if (!runtimeApp || !runtimeApp.enabled) {
+    if (!runtimeApp?.enabled) {
         ctx.status = 404;
         ctx.body = {
             code: 404,
@@ -96,30 +150,59 @@ const denyRuntimeAppAccess = (ctx, appName, capability) => {
     }
     return runtimeApp;
 };
-const dispatchRegisteredKoaRouters = async (ctx) => {
-    const registeredRouters = listRuntimeAppKoaRouters();
-    for (const item of registeredRouters) {
-        const runtimeApp = getRuntimeApp(item.name);
-        if (!runtimeApp || !runtimeApp.enabled || runtimeApp.status !== 'ready' || !hasRuntimeAppCapability(item.name, 'httpApi')) {
-            continue;
-        }
-        const routers = getRuntimeAppKoaRouters(item.name);
-        for (const koaRouter of routers) {
+const getRuntimeAppRouters = (appName) => {
+    const registerRouters = getChildrenApp(appName)?.register?.koaRouter;
+    const storedRouters = getRuntimeAppKoaRouters(appName);
+    return (storedRouters.length ? storedRouters : Array.isArray(registerRouters) ? registerRouters : registerRouters ? [registerRouters] : []).filter(Boolean);
+};
+const dispatchAppKoaRouters = async (ctx, appName) => {
+    const runtimeApp = getRuntimeApp(appName);
+    if (!runtimeApp || !runtimeApp.enabled || runtimeApp.status !== 'ready' || !hasRuntimeAppCapability(appName, 'httpApi')) {
+        return false;
+    }
+    const routers = getRuntimeAppRouters(appName);
+    const aliasBases = appName === 'main' ? ['/app'] : [`/apps/${appName}`];
+    for (const koaRouter of routers) {
+        for (const basePath of aliasBases) {
+            const rewrittenPath = matchBasePath(ctx.path, basePath);
+            if (!rewrittenPath) {
+                continue;
+            }
             try {
-                const beforeMatched = Array.isArray(ctx.matched) ? ctx.matched.length : 0;
-                await koaRouter.routes()(ctx, async () => { });
-                const afterMatched = Array.isArray(ctx.matched) ? ctx.matched.length : 0;
-                if (afterMatched <= beforeMatched) {
+                const matchedContext = ctx;
+                const beforeMatched = Array.isArray(matchedContext.matched) ? matchedContext.matched.length : 0;
+                const beforeStatus = ctx.status;
+                const beforeBody = ctx.body;
+                const beforeMatchedRoute = ctx._matchedRoute;
+                const beforeRouterPath = ctx.routerPath;
+                let fallthrough = false;
+                await rewriteCtxPath(ctx, rewrittenPath, async () => {
+                    await koaRouter.routes()(ctx, async () => {
+                        fallthrough = true;
+                    });
+                });
+                const afterMatched = Array.isArray(matchedContext.matched) ? matchedContext.matched.length : 0;
+                const afterMatchedRoute = ctx._matchedRoute;
+                const afterRouterPath = ctx.routerPath;
+                const handled = afterMatched > beforeMatched
+                    || afterMatchedRoute !== beforeMatchedRoute
+                    || afterRouterPath !== beforeRouterPath
+                    || ctx.status !== beforeStatus
+                    || ctx.body !== beforeBody
+                    || !fallthrough;
+                if (!handled) {
                     continue;
                 }
-                await koaRouter.allowedMethods()(ctx, async () => { });
+                await rewriteCtxPath(ctx, rewrittenPath, async () => {
+                    await koaRouter.allowedMethods()(ctx, async () => { });
+                });
                 return true;
             }
             catch (error) {
                 const handled = await dispatchHttpError({
                     ctx,
                     error,
-                    appName: item.name,
+                    appName,
                     path: ctx.path,
                     method: ctx.method,
                     kind: 'koa-router'
@@ -144,10 +227,112 @@ const dispatchRegisteredKoaRouters = async (ctx) => {
     }
     return false;
 };
+const isNamespacedHtmlRequest = (ctx) => {
+    if (ctx.method !== 'GET') {
+        return false;
+    }
+    if (ctx.path === '/app' || ctx.path.startsWith('/app/')) {
+        return !matchApiBasePath(ctx.path, '/app/api');
+    }
+    if (!ctx.path.startsWith('/apps/')) {
+        return false;
+    }
+    const [, , appName, segment = ''] = ctx.path.split('/');
+    if (!appName) {
+        return false;
+    }
+    return !matchApiBasePath(ctx.path, `/apps/${appName}/api`);
+};
+const dispatchRegisteredKoaRouters = async (ctx) => {
+    const registeredRouters = listRuntimeAppKoaRouters();
+    const candidates = new Set(registeredRouters.map(item => item.name));
+    const runtimeApps = listRuntimeApps();
+    runtimeApps.forEach(item => {
+        if (item.capabilities?.httpApi) {
+            candidates.add(item.name);
+        }
+    });
+    for (const appName of candidates) {
+        const handled = await dispatchAppKoaRouters(ctx, appName);
+        if (handled) {
+            return true;
+        }
+    }
+    return false;
+};
+const serveStaticResource = async (ctx, appName, rootDir, resourcePath) => {
+    const packageRoot = resolvePackageRoot(rootDir);
+    let root = '';
+    try {
+        root = readWebRootConfig(packageRoot);
+    }
+    catch (err) {
+        const handled = await dispatchHttpError({
+            ctx,
+            error: err,
+            appName,
+            path: ctx.path,
+            method: ctx.method,
+            kind: 'web'
+        });
+        if (handled) {
+            return 'handled';
+        }
+        ctx.status = 500;
+        ctx.body = {
+            code: 500,
+            message: '加载 package.json 时发生错误。',
+            error: err instanceof Error ? err.message : String(err)
+        };
+        return 'handled';
+    }
+    const webRoot = root ? path__default.join(packageRoot, root) : packageRoot;
+    const fullPath = safePath(webRoot, resourcePath);
+    if (!fullPath) {
+        ctx.status = 403;
+        ctx.body = {
+            code: 403,
+            message: '非法路径',
+            data: null
+        };
+        return 'handled';
+    }
+    if (!existsSync(fullPath)) {
+        return 'miss';
+    }
+    try {
+        const file = await fs__default.promises.readFile(fullPath);
+        const mimeType = mime.lookup(fullPath) || 'application/octet-stream';
+        ctx.set('Content-Type', mimeType);
+        ctx.body = file;
+        ctx.status = 200;
+        return 'handled';
+    }
+    catch (err) {
+        const handled = await dispatchHttpError({
+            ctx,
+            error: err,
+            appName,
+            path: ctx.path,
+            method: ctx.method,
+            kind: 'web'
+        });
+        if (handled) {
+            return 'handled';
+        }
+        ctx.status = 500;
+        ctx.body = {
+            code: 500,
+            message: appName === 'main' ? '加载资源时发生服务器错误。' : `加载子应用 '${appName}' 资源时发生服务器错误。`,
+            error: err instanceof Error ? err.message : String(err)
+        };
+        return 'handled';
+    }
+};
 router.get('/', ctx => {
     ctx.status = 200;
     ctx.set('Content-Type', 'text/html; charset=utf-8');
-    ctx.body = hello;
+    ctx.body = renderHelloHtml(listRuntimeApps());
 });
 router.get('api/online', ctx => {
     ctx.status = 200;
@@ -192,13 +377,21 @@ router.get('api/runtime/apps/:app', ctx => {
     };
 });
 router.use(async (ctx, next) => {
+    if (isNamespacedHtmlRequest(ctx)) {
+        await next();
+        return;
+    }
     const handled = await dispatchRegisteredKoaRouters(ctx);
     if (handled) {
         return;
     }
     await next();
 });
-router.all('app/{*path}', async (ctx) => {
+const handleMainAppRequest = async (ctx) => {
+    if (needsTrailingSlashRedirect(getOriginalPathname(ctx), '/app')) {
+        ctx.redirect('/app/');
+        return;
+    }
     if (!process.env.input) {
         ctx.status = 400;
         ctx.body = {
@@ -210,7 +403,7 @@ router.all('app/{*path}', async (ctx) => {
     }
     const rootPath = process.cwd();
     const apiPath = '/app/api';
-    if (ctx.path.startsWith(apiPath)) {
+    if (matchApiBasePath(ctx.path, apiPath)) {
         const runtimeApp = denyRuntimeAppAccess(ctx, 'main', 'httpApi');
         if (!runtimeApp) {
             return;
@@ -291,88 +484,36 @@ router.all('app/{*path}', async (ctx) => {
         ctx.status = 405;
         return;
     }
-    let root = '';
+    const runtimeApp = getRuntimeApp('main');
     const resourcePath = formatPath(ctx.params?.path);
-    const runtimeApp = denyRuntimeAppAccess(ctx, 'main', 'web');
-    if (!runtimeApp) {
+    if (!runtimeApp?.enabled || runtimeApp.status !== 'ready') {
+        denyRuntimeAppAccess(ctx, 'main', 'web');
         return;
     }
-    const packageRoot = resolvePackageRoot(runtimeApp.rootDir);
-    try {
-        root = readWebRootConfig(packageRoot);
-    }
-    catch (err) {
-        const handled = await dispatchHttpError({
-            ctx,
-            error: err,
-            appName: 'main',
-            path: ctx.path,
-            method: ctx.method,
-            kind: 'web'
-        });
-        if (handled) {
+    if (hasRuntimeAppCapability('main', 'web')) {
+        const staticResult = await serveStaticResource(ctx, 'main', runtimeApp.rootDir, resourcePath);
+        if (staticResult === 'handled') {
             return;
         }
-        ctx.status = 500;
-        ctx.body = {
-            code: 500,
-            message: '加载 package.json 时发生错误。',
-            error: err instanceof Error ? err.message : String(err)
-        };
-        return;
     }
-    const webRoot = root ? path__default.join(packageRoot, root) : packageRoot;
-    const fullPath = safePath(webRoot, resourcePath);
-    if (!fullPath) {
-        ctx.status = 403;
-        ctx.body = {
-            code: 403,
-            message: '非法路径',
-            data: null
-        };
+    if (await dispatchAppKoaRouters(ctx, 'main')) {
         return;
     }
-    try {
-        const file = await fs__default.promises.readFile(fullPath);
-        const mimeType = mime.lookup(fullPath) || 'application/octet-stream';
-        ctx.set('Content-Type', mimeType);
-        ctx.body = file;
-        ctx.status = 200;
-    }
-    catch (err) {
-        const handled = await dispatchHttpError({
-            ctx,
-            error: err,
-            appName: 'main',
-            path: ctx.path,
-            method: ctx.method,
-            kind: 'web'
-        });
-        if (handled) {
-            return;
-        }
-        if (err?.status === 404) {
-            ctx.status = 404;
-            ctx.body = {
-                code: 404,
-                message: '资源中未找到。',
-                data: null
-            };
-        }
-        else {
-            ctx.status = 500;
-            ctx.body = {
-                code: 500,
-                message: '加载资源时发生服务器错误。',
-                error: err instanceof Error ? err.message : String(err)
-            };
-        }
+    if (!hasRuntimeAppCapability('main', 'web')) {
+        denyRuntimeAppAccess(ctx, 'main', 'web');
+        return;
     }
-});
-router.all('app', ctx => {
-    ctx.redirect('/app/');
-});
-router.all('apps/:app/{*path}', async (ctx) => {
+    ctx.status = 404;
+    ctx.body = {
+        code: 404,
+        message: '资源中未找到。',
+        data: null
+    };
+};
+router.all('app', handleMainAppRequest);
+router.all('app/', handleMainAppRequest);
+router.all('app/{*path}', handleMainAppRequest);
+const handlePluginAppRequest = async (ctx) => {
     const appName = ctx.params.app;
     if (!isValidPackageName(appName)) {
         ctx.status = 400;
@@ -383,8 +524,12 @@ router.all('apps/:app/{*path}', async (ctx) => {
         };
         return;
     }
+    if (needsTrailingSlashRedirect(getOriginalPathname(ctx), `/apps/${appName}`)) {
+        ctx.redirect(`/apps/${appName}/`);
+        return;
+    }
     const apiPath = `/apps/${appName}/api`;
-    if (ctx.path.startsWith(apiPath)) {
+    if (matchApiBasePath(ctx.path, apiPath)) {
         const runtimeApp = denyRuntimeAppAccess(ctx, appName, 'httpApi');
         if (!runtimeApp) {
             return;
@@ -459,93 +604,34 @@ router.all('apps/:app/{*path}', async (ctx) => {
         ctx.status = 405;
         return;
     }
-    const runtimeApp = denyRuntimeAppAccess(ctx, appName, 'web');
-    if (!runtimeApp) {
-        return;
-    }
-    const packageRoot = resolvePackageRoot(runtimeApp.rootDir);
+    const runtimeApp = getRuntimeApp(appName);
     const resourcePath = formatPath(ctx.params?.path);
-    let root = '';
-    try {
-        root = readWebRootConfig(packageRoot);
+    if (!runtimeApp?.enabled || runtimeApp.status !== 'ready') {
+        denyRuntimeAppAccess(ctx, appName, 'web');
+        return;
     }
-    catch (err) {
-        const handled = await dispatchHttpError({
-            ctx,
-            error: err,
-            appName,
-            path: ctx.path,
-            method: ctx.method,
-            kind: 'web'
-        });
-        if (handled) {
+    if (hasRuntimeAppCapability(appName, 'web')) {
+        const staticResult = await serveStaticResource(ctx, appName, runtimeApp.rootDir, resourcePath);
+        if (staticResult === 'handled') {
             return;
         }
-        ctx.status = 500;
-        ctx.body = {
-            code: 500,
-            message: '加载 package.json 时发生错误。',
-            error: err instanceof Error ? err.message : String(err)
-        };
-        return;
     }
-    const webRoot = root ? path__default.join(packageRoot, root) : packageRoot;
-    const fullPath = safePath(webRoot, resourcePath);
-    if (!fullPath) {
-        ctx.status = 403;
-        ctx.body = {
-            code: 403,
-            message: '非法路径',
-            data: null
-        };
+    if (await dispatchAppKoaRouters(ctx, appName)) {
         return;
     }
-    try {
-        const file = await fs__default.promises.readFile(fullPath);
-        const mimeType = mime.lookup(fullPath) || 'application/octet-stream';
-        ctx.set('Content-Type', mimeType);
-        ctx.body = file;
-        ctx.status = 200;
-    }
-    catch (err) {
-        const handled = await dispatchHttpError({
-            ctx,
-            error: err,
-            appName,
-            path: ctx.path,
-            method: ctx.method,
-            kind: 'web'
-        });
-        if (handled) {
-            return;
-        }
-        if (err?.status === 404) {
-            ctx.status = 404;
-            ctx.body = {
-                code: 404,
-                message: `资源 '${resourcePath}' 在子应用 '${appName}' 中未找到。`,
-                data: null
-            };
-        }
-        else {
-            logger.warn({
-                code: ResultCode.Fail,
-                message: `Error request ${ctx.path}:`,
-                data: err instanceof Error ? err.message : String(err)
-            });
-            ctx.status = 500;
-            ctx.body = {
-                code: 500,
-                message: `加载子应用 '${appName}' 资源时发生服务器错误。`,
-                error: err instanceof Error ? err.message : String(err)
-            };
-        }
-    }
-});
-router.all('apps/:name', ctx => {
-    if (ctx.path === `/apps/${ctx.params.name}`) {
-        ctx.redirect(`/apps/${ctx.params.name}/`);
+    if (!hasRuntimeAppCapability(appName, 'web')) {
+        denyRuntimeAppAccess(ctx, appName, 'web');
+        return;
     }
-});
+    ctx.status = 404;
+    ctx.body = {
+        code: 404,
+        message: `资源 '${resourcePath}' 在子应用 '${appName}' 中未找到。`,
+        data: null
+    };
+};
+router.all('apps/:app', handlePluginAppRequest);
+router.all('apps/:app/', handlePluginAppRequest);
+router.all('apps/:app/{*path}', handlePluginAppRequest);
 
 export { router as default };

package/lib/{server → application/runtime/http}/routers/utils.d.ts

@@ -1,4 +1,4 @@
 export declare const safePath: (root: string, untrusted: string) => string | null;
 export declare const isValidPackageName: (name: string) => boolean;
 export declare const getModuelFile: (dir: string) => string;
-export declare const formatPath: (path: string) => string;
+export declare const formatPath: (pathValue: string) => string;

package/lib/{server → application/runtime/http}/routers/utils.js

@@ -34,17 +34,31 @@ const getModuelFile = (dir) => {
     }
     return '';
 };
-const formatPath = (path) => {
-    if (!path || path === '/') {
-        return '/index.html';
+const formatPath = (pathValue) => {
+    const normalizedPath = String(pathValue || '')
+        .replace(/\\/g, '/')
+        .replace(/^\/+/, '')
+        .replace(/\/{2,}/g, '/')
+        .trim();
+    if (!normalizedPath) {
+        return 'index.html';
+    }
+    if (normalizedPath === 'index' || normalizedPath === 'index.html') {
+        return 'index.html';
+    }
+    if (normalizedPath.endsWith('/')) {
+        return `${normalizedPath}index.html`;
+    }
+    const parts = normalizedPath.split('/');
+    const lastPath = parts[parts.length - 1];
+    if (lastPath === 'index' || lastPath === 'index.html') {
+        parts[parts.length - 1] = 'index.html';
+        return parts.join('/');
     }
-    const pates = path.split('/');
-    const lastPath = pates[pates.length - 1];
     if (lastPath.includes('.')) {
-        return path;
+        return normalizedPath;
     }
-    path += '.html';
-    return path;
+    return `${normalizedPath}.html`;
 };
 
 export { formatPath, getModuelFile, isValidPackageName, safePath };

package/lib/{server/main.js → application/runtime/http-server.js}

@@ -1,11 +1,7 @@
 import Koa from 'koa';
 import koaCors from '@koa/cors';
-import router from './routers/router.js';
-import { ResultCode } from '../core/variable.js';
-import 'fs';
-import 'path';
-import 'yaml';
-import '../core/utils.js';
+import router from './http/routers/router.js';
+import { ResultCode } from '../../common/variable.js';
 
 const createServer = (port, listeningListener) => {
     try {

package/lib/{app → application/runtime}/lifecycle-callbacks.d.ts

@@ -1,4 +1,4 @@
-import type { EventFinishedContext, EventStartContext, HttpErrorContext, RuntimeStatusChangeContext } from '../types';
+import type { EventFinishedContext, EventStartContext, HttpErrorContext, RuntimeStatusChangeContext } from '../../types/index.js';
 export declare const dispatchEventStart: (context: EventStartContext) => Promise<void>;
 export declare const dispatchEventFinished: (context: EventFinishedContext) => Promise<void>;
 export declare const dispatchHttpError: (context: HttpErrorContext) => Promise<boolean>;

package/lib/{app → application/runtime}/lifecycle-callbacks.js

@@ -1,4 +1,4 @@
-import { showErrorModule } from '../core/utils.js';
+import { showErrorModule } from '../../common/utils.js';
 
 const swallowLifecycleError = (error) => {
     showErrorModule(error instanceof Error ? error : new Error(typeof error === 'string' ? error : 'Unknown lifecycle error'));
@@ -65,12 +65,7 @@ const dispatchAppReady = async (appName, store) => {
     if (!handler) {
         return;
     }
-    try {
-        await handler(store);
-    }
-    catch (error) {
-        throw error;
-    }
+    await handler(store);
 };
 const dispatchAppDispose = async (appName, error) => {
     const app = getChildrenApp(appName);

package/lib/{app/load_modules → application/runtime/load-modules}/load.js

@@ -1,8 +1,8 @@
-import { getConfig } from '../../core/config.js';
+import { getConfig } from '../../../common/config.js';
 import { loadChildren, loadChildrenFile } from './loadChild.js';
 import { join, dirname } from 'path';
 import { existsSync } from 'fs';
-import { ResultCode } from '../../core/variable.js';
+import { ResultCode } from '../../../common/variable.js';
 import { registerRuntimeApp } from '../store.js';
 
 const loadApps = () => {