@yinuo-ngm/server 1.0.14 → 1.0.16

package/lib/routes/hub.routes.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = hubRoutes;
+const core_1 = require("@yinuo-ngm/core");
+const DEFAULT_HUB_PUBLIC_BASE_URL = "http://192.168.1.31:7070/api/public";
+function normalizeText(value, maxLen, fieldName) {
+    if (value === undefined || value === null)
+        return undefined;
+    if (typeof value !== "string") {
+        throw new core_1.AppError("BAD_REQUEST", `${fieldName} must be string`);
+    }
+    const text = value.trim();
+    if (text.length > maxLen) {
+        throw new core_1.AppError("BAD_REQUEST", `${fieldName} length must <= ${maxLen}`);
+    }
+    return text;
+}
+function validateBody(input) {
+    if (!input || typeof input !== "object") {
+        throw new core_1.AppError("BAD_REQUEST", "invalid feedback payload");
+    }
+    const body = input;
+    const category = body.category;
+    const title = normalizeText(body.title, 120, "title");
+    const content = normalizeText(body.content, 5000, "content");
+    const projectKey = normalizeText(body.projectKey, 80, "projectKey");
+    const contact = normalizeText(body.contact, 120, "contact");
+    const clientName = normalizeText(body.clientName, 120, "clientName");
+    const clientVersion = normalizeText(body.clientVersion, 60, "clientVersion");
+    const osInfo = normalizeText(body.osInfo, 200, "osInfo");
+    if (!category || !["bug", "suggestion", "feature", "other"].includes(category)) {
+        throw new core_1.AppError("BAD_REQUEST", "invalid feedback category");
+    }
+    if (!title) {
+        throw new core_1.AppError("BAD_REQUEST", "feedback title is required");
+    }
+    if (!content) {
+        throw new core_1.AppError("BAD_REQUEST", "feedback content is required");
+    }
+    return {
+        category,
+        title,
+        content,
+        projectKey,
+        contact,
+        clientName,
+        clientVersion,
+        osInfo,
+    };
+}
+function resolveClientIp(req) {
+    const xForwardedFor = req.headers?.["x-forwarded-for"];
+    if (typeof xForwardedFor === "string" && xForwardedFor.trim()) {
+        return xForwardedFor.split(",")[0]?.trim() || undefined;
+    }
+    return req.ip || req.socket?.remoteAddress || undefined;
+}
+async function hubRoutes(app) {
+    app.post("/feedback", async (req) => {
+        const body = validateBody(req.body);
+        const baseUrl = (process.env.NGM_HUB_PUBLIC_BASE_URL || DEFAULT_HUB_PUBLIC_BASE_URL).replace(/\/+$/, "");
+        const targetUrl = `${baseUrl}/feedbacks`;
+        let response;
+        try {
+            response = await fetch(targetUrl, {
+                method: "POST",
+                headers: {
+                    "content-type": "application/json",
+                },
+                body: JSON.stringify({
+                    source: "web",
+                    category: body.category,
+                    title: body.title,
+                    content: body.content,
+                    projectKey: body.projectKey,
+                    contact: body.contact,
+                    clientName: body.clientName,
+                    clientVersion: body.clientVersion,
+                    osInfo: body.osInfo,
+                    clientIp: resolveClientIp(req),
+                }),
+            });
+        }
+        catch (error) {
+            throw new core_1.AppError("UNKNOWN_ERROR", "failed to connect hub service", { cause: error?.message || String(error), targetUrl });
+        }
+        let payload = null;
+        try {
+            payload = await response.json();
+        }
+        catch {
+            payload = null;
+        }
+        if (!response.ok) {
+            const message = payload?.message || `hub response error (${response.status})`;
+            throw new core_1.AppError("UNKNOWN_ERROR", message, { status: response.status, payload });
+        }
+        if (payload?.code !== "OK") {
+            throw new core_1.AppError("UNKNOWN_ERROR", payload?.message || "hub feedback submit failed", { payload });
+        }
+        return payload?.data ?? payload;
+    });
+}

package/lib/routes/index.js

@@ -14,9 +14,12 @@ const sprite_routes_1 = require("./sprite.routes");
 const system_routes_1 = __importDefault(require("./system.routes"));
 const task_routes_1 = __importDefault(require("./task.routes"));
 const api_client_1 = require("./api-client");
+const nginx_routes_1 = require("./nginx.routes");
 const svn_routes_1 = __importDefault(require("./svn.routes"));
 const sprite_browse_routes_1 = __importDefault(require("./sprite-browse.routes"));
 const static_files_routes_1 = __importDefault(require("./static-files.routes"));
+const hub_routes_1 = __importDefault(require("./hub.routes"));
+const node_version_routes_1 = __importDefault(require("./node-version.routes"));
 async function routes(fastify) {
     await fastify.register(system_routes_1.default);
     await fastify.register(task_routes_1.default, { prefix: '/api/tasks' });
@@ -30,9 +33,13 @@ async function routes(fastify) {
     await fastify.register(svn_routes_1.default, { prefix: '/api/svn' });
     await fastify.register(sprite_browse_routes_1.default, { prefix: '/api/sprite/browse' });
     await fastify.register(static_files_routes_1.default, { prefix: '/api/static' });
+    await fastify.register(hub_routes_1.default, { prefix: '/api/hub' });
     await fastify.register(api_client_1.apiClientEnvsRoutes, { prefix: '/api/client/envs' });
     await fastify.register(api_client_1.apiClientRequestsRoutes, { prefix: '/api/client/requests' });
     await fastify.register(api_client_1.apiClientHistoryRoutes, { prefix: '/api/client/history' });
     await fastify.register(api_client_1.apiClientSendRoutes, { prefix: '/api/client/send' });
     await fastify.register(api_client_1.apiClientCollectionsRoutes, { prefix: '/api/client/collections' });
+    await fastify.register(api_client_1.apiClientHubTokenRoutes, { prefix: '/api/client/hub-token' });
+    await fastify.register(nginx_routes_1.nginxRoutes, { prefix: '/api/nginx' });
+    await fastify.register(node_version_routes_1.default, { prefix: '/api/node-version' });
 }

package/lib/routes/nginx/nginx-config.routes.d.ts

@@ -0,0 +1,2 @@
+import { NginxRouteContext } from './nginx-route.context';
+export declare function registerNginxConfigRoutes(context: NginxRouteContext): void;

package/lib/routes/nginx/nginx-config.routes.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerNginxConfigRoutes = registerNginxConfigRoutes;
+const nginx_route_context_1 = require("./nginx-route.context");
+function registerNginxConfigRoutes(context) {
+    const { fastify, nginx, normalizeFsPath, ensureManageableConfigFile } = context;
+    fastify.get('/config', async (_request, reply) => {
+        try {
+            const config = await nginx.config.readMainConfig();
+            return reply.send({
+                success: true,
+                config,
+            });
+        }
+        catch (error) {
+            return (0, nginx_route_context_1.sendBadRequest)(reply, error);
+        }
+    });
+    fastify.put('/config', async (request, reply) => {
+        const { content } = request.body;
+        try {
+            await nginx.config.writeMainConfig(content);
+            return reply.send({
+                success: true,
+            });
+        }
+        catch (error) {
+            return (0, nginx_route_context_1.sendBadRequest)(reply, error);
+        }
+    });
+    fastify.post('/config/validate', async (request, reply) => {
+        const { content } = request.body;
+        const result = await nginx.config.validateConfig(content);
+        return reply.send(result);
+    });
+    fastify.get('/config/files', async (_request, reply) => {
+        try {
+            const files = await nginx.config.getIncludedConfigs();
+            return reply.send({
+                success: true,
+                files,
+            });
+        }
+        catch (error) {
+            return (0, nginx_route_context_1.sendBadRequest)(reply, error);
+        }
+    });
+    fastify.get('/config/file', async (request, reply) => {
+        try {
+            const filePath = await ensureManageableConfigFile(request.query?.filePath);
+            const mainConfig = await nginx.config.readMainConfig();
+            const isMainConfig = normalizeFsPath(mainConfig.mainConfigPath) === normalizeFsPath(filePath);
+            if (isMainConfig) {
+                return reply.send({
+                    success: true,
+                    config: mainConfig,
+                });
+            }
+            const content = await nginx.config.readConfigFile(filePath);
+            const isWritable = await nginx.config.isConfigFileWritable(filePath);
+            return reply.send({
+                success: true,
+                config: {
+                    mainConfigPath: filePath,
+                    content,
+                    isWritable,
+                },
+            });
+        }
+        catch (error) {
+            return (0, nginx_route_context_1.sendBadRequest)(reply, error);
+        }
+    });
+    fastify.put('/config/file', async (request, reply) => {
+        try {
+            const filePath = await ensureManageableConfigFile(request.body?.filePath);
+            const content = request.body?.content ?? '';
+            const mainConfig = await nginx.config.readMainConfig();
+            const isMainConfig = normalizeFsPath(mainConfig.mainConfigPath) === normalizeFsPath(filePath);
+            if (isMainConfig) {
+                await nginx.config.writeMainConfig(content);
+            }
+            else {
+                await nginx.config.writeConfigFile(filePath, content);
+            }
+            return reply.send({
+                success: true,
+            });
+        }
+        catch (error) {
+            return (0, nginx_route_context_1.sendBadRequest)(reply, error);
+        }
+    });
+}

package/lib/routes/nginx/nginx-lifecycle.routes.d.ts

@@ -0,0 +1,2 @@
+import { NginxRouteContext } from './nginx-route.context';
+export declare function registerNginxLifecycleRoutes(context: NginxRouteContext): void;

package/lib/routes/nginx/nginx-lifecycle.routes.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerNginxLifecycleRoutes = registerNginxLifecycleRoutes;
+const nginx_binding_store_1 = require("../../plugins/nginx.binding.store");
+const nginx_route_context_1 = require("./nginx-route.context");
+function registerNginxLifecycleRoutes(context) {
+    const { fastify, nginx } = context;
+    fastify.get('/status', async (_request, reply) => {
+        const instance = nginx.service.getInstance();
+        const status = await nginx.service.getStatus();
+        return reply.send({
+            instance,
+            status,
+        });
+    });
+    fastify.get('/stats', async (_request, reply) => {
+        try {
+            const instance = nginx.service.getInstance();
+            const status = await nginx.service.getStatus();
+            const servers = await nginx.server.getAllServers();
+            const enabled = servers.filter(item => item.enabled).length;
+            return reply.send({
+                success: true,
+                instance,
+                status,
+                serverSummary: {
+                    total: servers.length,
+                    enabled,
+                    disabled: Math.max(servers.length - enabled, 0),
+                },
+            });
+        }
+        catch (error) {
+            return (0, nginx_route_context_1.sendBadRequest)(reply, error);
+        }
+    });
+    fastify.post('/bind', async (request, reply) => {
+        const { path } = request.body;
+        try {
+            const instance = await nginx.service.bind(path);
+            try {
+                await (0, nginx_binding_store_1.savePersistedNginxPath)(instance.path);
+            }
+            catch (persistError) {
+                fastify.log.warn(`[nginx] binding persisted failed: ${String(persistError)}`);
+            }
+            return reply.send({
+                success: true,
+                instance,
+            });
+        }
+        catch (error) {
+            return (0, nginx_route_context_1.sendBadRequest)(reply, error);
+        }
+    });
+    fastify.post('/unbind', async (_request, reply) => {
+        nginx.service.unbind();
+        try {
+            await (0, nginx_binding_store_1.clearPersistedNginxPath)();
+        }
+        catch (error) {
+            fastify.log.warn(`[nginx] clear persisted binding failed: ${String(error)}`);
+        }
+        return reply.send({
+            success: true,
+        });
+    });
+    fastify.post('/start', async (_request, reply) => {
+        const result = await nginx.service.start();
+        if (result.success) {
+            fastify.core.sysLog.info({ scope: 'system', source: 'server', text: '[Nginx] 启动成功' });
+        }
+        else {
+            fastify.core.sysLog.error({ scope: 'system', source: 'server', text: `[Nginx] 启动失败: ${result.error || '未知错误'}` });
+        }
+        return reply.send(result);
+    });
+    fastify.post('/stop', async (_request, reply) => {
+        const result = await nginx.service.stop();
+        if (result.success) {
+            fastify.core.sysLog.warn({ scope: 'system', source: 'server', text: '[Nginx] 已停止' });
+        }
+        else {
+            fastify.core.sysLog.error({ scope: 'system', source: 'server', text: `[Nginx] 停止失败: ${result.error || '未知错误'}` });
+        }
+        return reply.send(result);
+    });
+    fastify.post('/reload', async (_request, reply) => {
+        const result = await nginx.service.reload();
+        if (result.success) {
+            fastify.core.sysLog.info({ scope: 'system', source: 'server', text: '[Nginx] 配置重载成功' });
+        }
+        else {
+            fastify.core.sysLog.error({ scope: 'system', source: 'server', text: `[Nginx] 重载失败: ${result.error || '未知错误'}` });
+        }
+        return reply.send(result);
+    });
+    fastify.post('/test', async (_request, reply) => {
+        const result = await nginx.service.testConfig();
+        if (result.valid) {
+            fastify.core.sysLog.success({ scope: 'system', source: 'server', text: '[Nginx] 配置检测通过' });
+        }
+        else {
+            fastify.core.sysLog.error({ scope: 'system', source: 'server', text: `[Nginx] 配置检测失败: ${(result.errors || []).join(', ')}` });
+        }
+        return reply.send(result);
+    });
+}

package/lib/routes/nginx/nginx-log.routes.d.ts

@@ -0,0 +1,2 @@
+import { NginxRouteContext } from './nginx-route.context';
+export declare function registerNginxLogRoutes(context: NginxRouteContext): void;

package/lib/routes/nginx/nginx-log.routes.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerNginxLogRoutes = registerNginxLogRoutes;
+const nginx_route_context_1 = require("./nginx-route.context");
+function registerNginxLogRoutes(context) {
+    const { fastify, nginx } = context;
+    fastify.get('/logs/error', async (request, reply) => {
+        try {
+            const tail = Math.max(1, Math.min(1000, Number(request.query?.tail ?? 100)));
+            const lines = await nginx.log.readLogTail('error', tail);
+            return reply.send({
+                success: true,
+                lines,
+            });
+        }
+        catch (error) {
+            return (0, nginx_route_context_1.sendBadRequest)(reply, error);
+        }
+    });
+    fastify.get('/logs/access', async (request, reply) => {
+        try {
+            const tail = Math.max(1, Math.min(1000, Number(request.query?.tail ?? 100)));
+            const lines = await nginx.log.readLogTail('access', tail);
+            return reply.send({
+                success: true,
+                lines,
+            });
+        }
+        catch (error) {
+            return (0, nginx_route_context_1.sendBadRequest)(reply, error);
+        }
+    });
+    fastify.get('/logs/info', async (_request, reply) => {
+        try {
+            const errorPath = nginx.log.getLogFilePath('error');
+            const accessPath = nginx.log.getLogFilePath('access');
+            return reply.send({
+                success: true,
+                errorLog: errorPath,
+                accessLog: accessPath,
+            });
+        }
+        catch (error) {
+            return (0, nginx_route_context_1.sendBadRequest)(reply, error);
+        }
+    });
+}

package/lib/routes/nginx/nginx-module.routes.d.ts

@@ -0,0 +1,2 @@
+import { NginxRouteContext } from './nginx-route.context';
+export declare function registerNginxModuleRoutes(context: NginxRouteContext): void;

package/lib/routes/nginx/nginx-module.routes.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerNginxModuleRoutes = registerNginxModuleRoutes;
+const nginx_route_context_1 = require("./nginx-route.context");
+function registerNginxModuleRoutes(context) {
+    const { fastify, nginx } = context;
+    fastify.get('/upstreams', async (_request, reply) => {
+        try {
+            const upstreams = await nginx.module.getUpstreams();
+            return reply.send({
+                success: true,
+                upstreams,
+            });
+        }
+        catch (error) {
+            return (0, nginx_route_context_1.sendBadRequest)(reply, error);
+        }
+    });
+    fastify.put('/upstreams', async (request, reply) => {
+        try {
+            await nginx.module.saveUpstreams(request.body?.upstreams || []);
+            return reply.send({
+                success: true,
+            });
+        }
+        catch (error) {
+            return (0, nginx_route_context_1.sendBadRequest)(reply, error);
+        }
+    });
+    fastify.get('/ssl/certificates', async (_request, reply) => {
+        try {
+            const certificates = await nginx.module.getSslCertificates();
+            return reply.send({
+                success: true,
+                certificates,
+            });
+        }
+        catch (error) {
+            return (0, nginx_route_context_1.sendBadRequest)(reply, error);
+        }
+    });
+    fastify.put('/ssl/certificates', async (request, reply) => {
+        try {
+            await nginx.module.saveSslCertificates(request.body?.certificates || []);
+            return reply.send({
+                success: true,
+            });
+        }
+        catch (error) {
+            return (0, nginx_route_context_1.sendBadRequest)(reply, error);
+        }
+    });
+    fastify.get('/traffic', async (_request, reply) => {
+        try {
+            const traffic = await nginx.module.getTrafficConfig();
+            return reply.send({
+                success: true,
+                traffic,
+            });
+        }
+        catch (error) {
+            return (0, nginx_route_context_1.sendBadRequest)(reply, error);
+        }
+    });
+    fastify.put('/traffic', async (request, reply) => {
+        try {
+            await nginx.module.saveTrafficConfig(request.body);
+            return reply.send({
+                success: true,
+            });
+        }
+        catch (error) {
+            return (0, nginx_route_context_1.sendBadRequest)(reply, error);
+        }
+    });
+    fastify.get('/performance', async (_request, reply) => {
+        try {
+            const performance = await nginx.module.getPerformanceConfig();
+            return reply.send({
+                success: true,
+                performance,
+            });
+        }
+        catch (error) {
+            return (0, nginx_route_context_1.sendBadRequest)(reply, error);
+        }
+    });
+    fastify.put('/performance', async (request, reply) => {
+        try {
+            await nginx.module.savePerformanceConfig(request.body);
+            return reply.send({
+                success: true,
+            });
+        }
+        catch (error) {
+            return (0, nginx_route_context_1.sendBadRequest)(reply, error);
+        }
+    });
+    fastify.get('/module/settings', async (_request, reply) => {
+        try {
+            const settings = await nginx.module.getModuleSettings();
+            return reply.send({
+                success: true,
+                settings,
+            });
+        }
+        catch (error) {
+            return (0, nginx_route_context_1.sendBadRequest)(reply, error);
+        }
+    });
+    fastify.put('/module/settings', async (request, reply) => {
+        try {
+            const settings = await nginx.module.saveModuleSettings(request.body || {});
+            return reply.send({
+                success: true,
+                settings,
+            });
+        }
+        catch (error) {
+            return (0, nginx_route_context_1.sendBadRequest)(reply, error);
+        }
+    });
+}

package/lib/routes/nginx/nginx-route.context.d.ts

@@ -0,0 +1,9 @@
+import type { FastifyInstance, FastifyReply } from 'fastify';
+export interface NginxRouteContext {
+    fastify: FastifyInstance;
+    nginx: FastifyInstance['nginx'];
+    normalizeFsPath: (filePath: string) => string;
+    ensureManageableConfigFile: (rawPath?: string) => Promise<string>;
+}
+export declare function createNginxRouteContext(fastify: FastifyInstance): NginxRouteContext;
+export declare function sendBadRequest(reply: FastifyReply, error: unknown): void;

package/lib/routes/nginx/nginx-route.context.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNginxRouteContext = createNginxRouteContext;
+exports.sendBadRequest = sendBadRequest;
+const path_1 = require("path");
+const core_1 = require("@yinuo-ngm/core");
+function createNginxRouteContext(fastify) {
+    const nginx = fastify.nginx;
+    const normalizeFsPath = (filePath) => (0, path_1.resolve)(filePath).replace(/\\/g, '/').toLowerCase();
+    const ensureManageableConfigFile = async (rawPath) => {
+        const filePath = rawPath?.trim();
+        if (!filePath) {
+            throw new Error('配置文件路径不能为空');
+        }
+        const included = await nginx.config.getIncludedConfigs();
+        const includedSet = new Set(included.map(item => normalizeFsPath(item)));
+        const normalizedTarget = normalizeFsPath(filePath);
+        if (!includedSet.has(normalizedTarget)) {
+            throw new Error('配置文件不在当前可管理列表中');
+        }
+        return (0, path_1.resolve)(filePath);
+    };
+    return {
+        fastify,
+        nginx,
+        normalizeFsPath,
+        ensureManageableConfigFile,
+    };
+}
+function sendBadRequest(reply, error) {
+    const message = error instanceof Error ? error.message : String(error ?? '未知错误');
+    throw new core_1.AppError('BAD_REQUEST', message, {
+        route: reply.request?.url,
+        method: reply.request?.method,
+    });
+}

package/lib/routes/nginx/nginx-server.routes.d.ts

@@ -0,0 +1,2 @@
+import { NginxRouteContext } from './nginx-route.context';
+export declare function registerNginxServerRoutes(context: NginxRouteContext): void;

package/lib/routes/nginx/nginx-server.routes.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerNginxServerRoutes = registerNginxServerRoutes;
+const core_1 = require("@yinuo-ngm/core");
+const nginx_route_context_1 = require("./nginx-route.context");
+function registerNginxServerRoutes(context) {
+    const { fastify, nginx } = context;
+    fastify.get('/servers', async (_request, reply) => {
+        try {
+            const servers = await nginx.server.getAllServers();
+            return reply.send({
+                success: true,
+                servers,
+            });
+        }
+        catch (error) {
+            return (0, nginx_route_context_1.sendBadRequest)(reply, error);
+        }
+    });
+    fastify.get('/servers/:id', async (request, reply) => {
+        const { id } = request.params;
+        try {
+            const server = await nginx.server.getServer(id);
+            if (!server) {
+                throw new core_1.AppError('NOT_FOUND', 'Server 不存在');
+            }
+            return reply.send({
+                success: true,
+                server,
+            });
+        }
+        catch (error) {
+            return (0, nginx_route_context_1.sendBadRequest)(reply, error);
+        }
+    });
+    fastify.post('/servers', async (request, reply) => {
+        try {
+            const server = await nginx.server.createServer(request.body);
+            return reply.send({
+                success: true,
+                server,
+            });
+        }
+        catch (error) {
+            return (0, nginx_route_context_1.sendBadRequest)(reply, error);
+        }
+    });
+    fastify.put('/servers/:id', async (request, reply) => {
+        const { id } = request.params;
+        try {
+            const server = await nginx.server.updateServer(id, request.body);
+            return reply.send({
+                success: true,
+                server,
+            });
+        }
+        catch (error) {
+            return (0, nginx_route_context_1.sendBadRequest)(reply, error);
+        }
+    });
+    fastify.delete('/servers/:id', async (request, reply) => {
+        const { id } = request.params;
+        try {
+            await nginx.server.deleteServer(id);
+            return reply.send({
+                success: true,
+            });
+        }
+        catch (error) {
+            return (0, nginx_route_context_1.sendBadRequest)(reply, error);
+        }
+    });
+    fastify.patch('/servers/:id/enable', async (request, reply) => {
+        const { id } = request.params;
+        try {
+            await nginx.server.enableServer(id);
+            return reply.send({
+                success: true,
+            });
+        }
+        catch (error) {
+            return (0, nginx_route_context_1.sendBadRequest)(reply, error);
+        }
+    });
+    fastify.patch('/servers/:id/disable', async (request, reply) => {
+        const { id } = request.params;
+        try {
+            await nginx.server.disableServer(id);
+            return reply.send({
+                success: true,
+            });
+        }
+        catch (error) {
+            return (0, nginx_route_context_1.sendBadRequest)(reply, error);
+        }
+    });
+}

package/lib/routes/nginx.routes.d.ts

@@ -0,0 +1,2 @@
+import type { FastifyInstance } from 'fastify';
+export declare function nginxRoutes(fastify: FastifyInstance): Promise<void>;