}
69 | */
70 | async function sendTelegramNotification(message, config) {
71 | const { telegramToken, telegramChatId } = config;
72 |
73 | if (!telegramToken || !telegramChatId) {
74 | throw new Error('Telegram Token 或 Chat ID 未配置');
75 | }
76 |
77 | const text = `*${message.title}*\n\n${message.content}\n\n_${message.time}_`;
78 | const url = `https://api.telegram.org/bot${telegramToken}/sendMessage`;
79 |
80 | try {
81 | const response = await axios.post(url, {
82 | chat_id: telegramChatId,
83 | text: text,
84 | parse_mode: 'Markdown'
85 | }, {
86 | headers: { 'Content-Type': 'application/json' },
87 | timeout: 5000
88 | });
89 |
90 | if (response.status !== 200 || !response.data.ok) {
91 | throw new Error(`Telegram 返回错误: ${response.data.description || '未知错误'}`);
92 | }
93 |
94 | logger.info('Telegram 通知发送成功');
95 | } catch (error) {
96 | logger.error('Telegram 通知发送失败:', error);
97 | throw new Error(`Telegram 通知发送失败: ${error.message}`);
98 | }
99 | }
100 |
101 | module.exports = {
102 | sendNotification
103 | };
104 |
--------------------------------------------------------------------------------
/hubcmdui/services/systemService.js:
--------------------------------------------------------------------------------
1 | /**
2 | * 系统服务模块 - 处理系统级信息获取
3 | * 使用 systeminformation 库来提供跨平台的系统数据
4 | */
5 | const si = require('systeminformation');
6 | const logger = require('../logger');
7 | const os = require('os'); // os模块仍可用于某些特定情况或日志记录
8 |
9 | // Helper function to format bytes into a more readable format
10 | function formatBytes(bytes, decimals = 2) {
11 | if (bytes === null || bytes === undefined || isNaN(bytes) || bytes === 0) return '0 Bytes';
12 | const k = 1024;
13 | const dm = decimals < 0 ? 0 : decimals;
14 | const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];
15 | try {
16 | const i = Math.floor(Math.log(bytes) / Math.log(k));
17 | return parseFloat((bytes / Math.pow(k, i)).toFixed(dm)) + ' ' + sizes[i];
18 | } catch (e) {
19 | return 'N/A'; // In case of Math.log error with very small numbers etc.
20 | }
21 | }
22 |
23 | // 获取核心系统资源信息 (CPU, Memory, Disk)
24 | async function getSystemResources() {
25 | try {
26 | logger.info('Fetching system resources using systeminformation...');
27 |
28 | // 并行获取数据以提高效率
29 | const [cpuInfo, memInfo, fsInfo, cpuLoadInfo, osInfo] = await Promise.all([
30 | si.cpu(), // For CPU model, cores, speed
31 | si.mem(), // For memory details
32 | si.fsSize(), // For filesystem details
33 | si.currentLoad(), // For current CPU load percentage and per-core load
34 | si.osInfo() // For OS type, mainly for specific disk selection if needed
35 | ]);
36 |
37 | // --- CPU 信息处理 ---
38 | let cpuUsage = parseFloat(cpuLoadInfo.currentLoad.toFixed(1));
39 | // Fallback if currentLoad is not a number (very unlikely with systeminformation)
40 | if (isNaN(cpuUsage) && Array.isArray(cpuLoadInfo.cpus) && cpuLoadInfo.cpus.length > 0) {
41 | // Calculate average from per-core loads if overall isn't good
42 | const totalLoad = cpuLoadInfo.cpus.reduce((acc, core) => acc + core.load, 0);
43 | cpuUsage = parseFloat((totalLoad / cpuLoadInfo.cpus.length).toFixed(1));
44 | }
45 | if (isNaN(cpuUsage)) cpuUsage = null; // Final fallback to null if still NaN
46 |
47 | const cpuData = {
48 | cores: cpuInfo.cores,
49 | physicalCores: cpuInfo.physicalCores,
50 | model: cpuInfo.manufacturer + ' ' + cpuInfo.brand,
51 | speed: cpuInfo.speed, // in GHz
52 | usage: cpuUsage, // Overall CPU usage percentage
53 | loadAvg: osInfo.platform !== 'win32' ? os.loadavg().map(load => parseFloat(load.toFixed(1))) : null // os.loadavg() is not for Windows
54 | };
55 |
56 | // --- 内存信息处理 ---
57 | // systeminformation already provides these in bytes
58 | const memData = {
59 | total: memInfo.total,
60 | free: memInfo.free, // Truly free
61 | used: memInfo.used, // total - free (includes buff/cache on Linux, PhysMem used on macOS)
62 | active: memInfo.active, // More representative of app-used memory
63 | available: memInfo.available, // Memory available to applications (often free + reclaimable buff/cache)
64 | wired: memInfo.wired, // macOS specific: memory that cannot be paged out
65 | // compressed: memInfo.compressed, // macOS specific, if systeminformation lib provides it directly
66 | buffcache: memInfo.buffcache // Linux specific: buffer and cache
67 | };
68 |
69 | // --- 磁盘信息处理 ---
70 | // Find the primary disk (e.g., mounted on '/' for Linux/macOS, or C: for Windows)
71 | let mainDiskInfo = null;
72 | if (osInfo.platform === 'win32') {
73 | mainDiskInfo = fsInfo.find(d => d.fs.startsWith('C:'));
74 | } else {
75 | mainDiskInfo = fsInfo.find(d => d.mount === '/');
76 | }
77 | if (!mainDiskInfo && fsInfo.length > 0) {
78 | // Fallback to the first disk if the standard one isn't found
79 | mainDiskInfo = fsInfo[0];
80 | }
81 |
82 | const diskData = mainDiskInfo ? {
83 | mount: mainDiskInfo.mount,
84 | size: formatBytes(mainDiskInfo.size),
85 | used: formatBytes(mainDiskInfo.used),
86 | available: formatBytes(mainDiskInfo.available), // systeminformation provides 'available'
87 | percent: mainDiskInfo.use !== null && mainDiskInfo.use !== undefined ? mainDiskInfo.use.toFixed(0) + '%' : 'N/A'
88 | } : {
89 | mount: 'N/A',
90 | size: 'N/A',
91 | used: 'N/A',
92 | available: 'N/A',
93 | percent: 'N/A'
94 | };
95 |
96 | const resources = {
97 | osType: osInfo.platform, // e.g., 'darwin', 'linux', 'win32'
98 | osDistro: osInfo.distro,
99 | cpu: cpuData,
100 | memory: memData,
101 | disk: diskData
102 | };
103 | logger.info('Successfully fetched system resources:', /* JSON.stringify(resources, null, 2) */ resources.osType);
104 | return resources;
105 |
106 | } catch (error) {
107 | logger.error('获取系统资源失败 (services/systemService.js):', error);
108 | // Return a structured error object or rethrow,
109 | // so the API route can send an appropriate HTTP error
110 | throw new Error(`Failed to get system resources: ${error.message}`);
111 | }
112 | }
113 |
114 | module.exports = {
115 | getSystemResources
116 | // getDiskSpace, if it was previously exported and used by another route, can be kept
117 | // or removed if getSystemResources now covers all disk info needs for /api/system-resources
118 | };
119 |
--------------------------------------------------------------------------------
/hubcmdui/services/userService.js:
--------------------------------------------------------------------------------
1 | /**
2 | * 用户服务模块
3 | */
4 | const fs = require('fs').promises;
5 | const path = require('path');
6 | const bcrypt = require('bcrypt');
7 | const logger = require('../logger');
8 |
9 | const USERS_FILE = path.join(__dirname, '..', 'users.json');
10 |
11 | // 获取所有用户
12 | async function getUsers() {
13 | try {
14 | const data = await fs.readFile(USERS_FILE, 'utf8');
15 | return JSON.parse(data);
16 | } catch (error) {
17 | if (error.code === 'ENOENT') {
18 | logger.warn('Users file does not exist, creating default user');
19 | const defaultUser = {
20 | username: 'root',
21 | password: bcrypt.hashSync('admin', 10),
22 | createdAt: new Date().toISOString(),
23 | loginCount: 0,
24 | lastLogin: null
25 | };
26 | await saveUsers([defaultUser]);
27 | return { users: [defaultUser] };
28 | }
29 | throw error;
30 | }
31 | }
32 |
33 | // 保存用户
34 | async function saveUsers(users) {
35 | await fs.writeFile(USERS_FILE, JSON.stringify({ users }, null, 2), 'utf8');
36 | }
37 |
38 | // 更新用户登录信息
39 | async function updateUserLoginInfo(username) {
40 | try {
41 | const { users } = await getUsers();
42 | const user = users.find(u => u.username === username);
43 |
44 | if (user) {
45 | user.loginCount = (user.loginCount || 0) + 1;
46 | user.lastLogin = new Date().toISOString();
47 | await saveUsers(users);
48 | }
49 | } catch (error) {
50 | logger.error('更新用户登录信息失败:', error);
51 | }
52 | }
53 |
54 | // 获取用户统计信息
55 | async function getUserStats(username) {
56 | try {
57 | const { users } = await getUsers();
58 | const user = users.find(u => u.username === username);
59 |
60 | if (!user) {
61 | return { loginCount: '0', lastLogin: '未知', accountAge: '0' };
62 | }
63 |
64 | // 计算账户年龄（如果有创建日期）
65 | let accountAge = '0';
66 | if (user.createdAt) {
67 | const createdDate = new Date(user.createdAt);
68 | const currentDate = new Date();
69 | const diffTime = Math.abs(currentDate - createdDate);
70 | const diffDays = Math.ceil(diffTime / (1000 * 60 * 60 * 24));
71 | accountAge = diffDays.toString();
72 | }
73 |
74 | // 格式化最后登录时间
75 | let lastLogin = '未知';
76 | if (user.lastLogin) {
77 | const lastLoginDate = new Date(user.lastLogin);
78 | const now = new Date();
79 | const isToday = lastLoginDate.toDateString() === now.toDateString();
80 |
81 | if (isToday) {
82 | lastLogin = '今天 ' + lastLoginDate.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });
83 | } else {
84 | lastLogin = lastLoginDate.toLocaleDateString() + ' ' + lastLoginDate.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });
85 | }
86 | }
87 |
88 | return {
89 | username: user.username,
90 | loginCount: (user.loginCount || 0).toString(),
91 | lastLogin,
92 | accountAge
93 | };
94 | } catch (error) {
95 | logger.error('获取用户统计信息失败:', error);
96 | return { loginCount: '0', lastLogin: '未知', accountAge: '0' };
97 | }
98 | }
99 |
100 | // 创建新用户
101 | async function createUser(username, password) {
102 | try {
103 | const { users } = await getUsers();
104 |
105 | // 检查用户是否已存在
106 | if (users.some(u => u.username === username)) {
107 | throw new Error('用户名已存在');
108 | }
109 |
110 | const hashedPassword = bcrypt.hashSync(password, 10);
111 | const newUser = {
112 | username,
113 | password: hashedPassword,
114 | createdAt: new Date().toISOString(),
115 | loginCount: 0,
116 | lastLogin: null
117 | };
118 |
119 | users.push(newUser);
120 | await saveUsers(users);
121 |
122 | return { success: true, username };
123 | } catch (error) {
124 | logger.error('创建用户失败:', error);
125 | throw error;
126 | }
127 | }
128 |
129 | // 修改用户密码
130 | async function changePassword(username, currentPassword, newPassword) {
131 | try {
132 | const { users } = await getUsers();
133 | const user = users.find(u => u.username === username);
134 |
135 | if (!user) {
136 | throw new Error('用户不存在');
137 | }
138 |
139 | // 验证当前密码
140 | const isMatch = await bcrypt.compare(currentPassword, user.password);
141 | if (!isMatch) {
142 | throw new Error('当前密码不正确');
143 | }
144 |
145 | // 验证新密码复杂度（虽然前端做了，后端再做一层保险）
146 | if (!isPasswordComplex(newPassword)) {
147 | throw new Error('新密码不符合复杂度要求');
148 | }
149 |
150 | // 更新密码
151 | user.password = await bcrypt.hash(newPassword, 10);
152 | await saveUsers(users);
153 |
154 | logger.info(`用户 ${username} 密码已成功修改`);
155 | } catch (error) {
156 | logger.error('修改密码失败:', error);
157 | throw error;
158 | }
159 | }
160 |
161 | // 验证密码复杂度 (从 userCenter.js 复制过来并调整)
162 | function isPasswordComplex(password) {
163 | // 至少包含1个字母、1个数字和1个特殊字符，长度在8-16位之间
164 | const passwordRegex = /^(?=.*[A-Za-z])(?=.*\d)(?=.*[.,\-_+=()[\]{}|\\;:'"<>?/@$!%*#?&])[A-Za-z\d.,\-_+=()[\]{}|\\;:'"<>?/@$!%*#?&]{8,16}$/;
165 | return passwordRegex.test(password);
166 | }
167 |
168 | module.exports = {
169 | getUsers,
170 | saveUsers,
171 | updateUserLoginInfo,
172 | getUserStats,
173 | createUser,
174 | changePassword
175 | };
176 |
--------------------------------------------------------------------------------
/hubcmdui/start-diagnostic.js:
--------------------------------------------------------------------------------
1 | /**
2 | * 诊断启动脚本 - 运行诊断并安全启动服务器
3 | */
4 | const { spawn } = require('child_process');
5 | const path = require('path');
6 | const fs = require('fs');
7 | const { runDiagnostics } = require('./scripts/diagnostics');
8 |
9 | // 确保必要的模块存在
10 | try {
11 | require('./logger');
12 | } catch (error) {
13 | console.error('无法加载logger模块，请确保该模块存在:', error.message);
14 | process.exit(1);
15 | }
16 |
17 | const logger = require('./logger');
18 |
19 | async function startWithDiagnostics() {
20 | logger.info('正在运行系统诊断...');
21 |
22 | try {
23 | // 运行诊断
24 | const { criticalErrors } = await runDiagnostics();
25 |
26 | if (criticalErrors.length > 0) {
27 | logger.error('发现严重问题，无法启动系统。请修复问题后重试。');
28 | process.exit(1);
29 | }
30 |
31 | logger.success('诊断通过，正在启动系统...');
32 |
33 | // 启动服务器
34 | const serverProcess = spawn('node', ['server.js'], {
35 | stdio: 'inherit',
36 | cwd: __dirname
37 | });
38 |
39 | serverProcess.on('close', (code) => {
40 | if (code !== 0) {
41 | logger.error(`服务器进程异常退出，退出码: ${code}`);
42 | process.exit(code);
43 | }
44 | });
45 |
46 | serverProcess.on('error', (err) => {
47 | logger.error('启动服务器进程时出错:', err);
48 | process.exit(1);
49 | });
50 |
51 | } catch (error) {
52 | logger.fatal('诊断过程中发生错误:', error);
53 | process.exit(1);
54 | }
55 | }
56 |
57 | // 启动服务
58 | startWithDiagnostics();
59 |
--------------------------------------------------------------------------------
/hubcmdui/users.json:
--------------------------------------------------------------------------------
1 | {
2 | "users": [
3 | {
4 | "username": "root",
5 | "password": "$2b$10$HBYJPwEB1gdRxcc6Bm1mKukxCC8eyJOZC7sGJN5meghvsBfoQjKtW",
6 | "loginCount": 0,
7 | "lastLogin": "2025-05-10T11:37:31.774Z"
8 | }
9 | ]
10 | }
--------------------------------------------------------------------------------
/hubcmdui/web/.DS_Store:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dqzboy/Docker-Proxy/04cfa607b87f46acd6f8904f6e0be96ab6057b45/hubcmdui/web/.DS_Store
--------------------------------------------------------------------------------
/hubcmdui/web/compatibility-layer.js:
--------------------------------------------------------------------------------
1 | // ... existing code ...
2 | // 获取文档列表
3 | app.get('/api/documentation', requireLogin, async (req, res) => {
4 | try {
5 | const docList = await getDocumentList();
6 | res.json(docList);
7 | } catch (error) {
8 | console.error('获取文档列表失败:', error);
9 | res.status(500).json({ error: '获取文档列表失败', details: error.message });
10 | }
11 | });
12 |
13 | // 获取单个文档内容
14 | app.get('/api/documentation/:id', requireLogin, async (req, res) => {
15 | const docId = req.params.id;
16 | console.log(`获取文档内容请求，ID: ${docId}`);
17 |
18 | try {
19 | // 获取文档列表
20 | const docList = await getDocumentList();
21 |
22 | // 查找指定ID的文档
23 | const doc = docList.find(doc => doc.id === docId || doc._id === docId);
24 |
25 | if (!doc) {
26 | return res.status(404).json({ error: '文档不存在', docId });
27 | }
28 |
29 | // 如果文档未发布且用户不是管理员，则拒绝访问
30 | if (!doc.published && !isAdmin(req.user)) {
31 | return res.status(403).json({ error: '无权访问未发布的文档' });
32 | }
33 |
34 | // 获取文档完整内容
35 | const docContent = await getDocumentContent(docId);
36 |
37 | // 合并文档信息和内容
38 | const fullDoc = {
39 | ...doc,
40 | content: docContent
41 | };
42 |
43 | res.json(fullDoc);
44 | } catch (error) {
45 | console.error(`获取文档内容失败，ID: ${docId}`, error);
46 | res.status(500).json({
47 | error: '获取文档内容失败',
48 | details: error.message,
49 | docId
50 | });
51 | }
52 | });
53 | // ... existing code ...
--------------------------------------------------------------------------------
/hubcmdui/web/css/admin.css:
--------------------------------------------------------------------------------
1 | /* 今天登录的高亮样式 */
2 | .today-login {
3 | background-color: #e6f7ff;
4 | color: #1890ff;
5 | padding: 2px 8px;
6 | border-radius: 4px;
7 | font-weight: 500;
8 | display: inline-block;
9 | }
10 |
11 | /* 用户信息显示优化 */
12 | .account-info-item {
13 | margin-bottom: 15px;
14 | display: flex;
15 | align-items: center;
16 | }
17 |
18 | .account-info-item .label {
19 | font-weight: 500;
20 | width: 120px;
21 | flex-shrink: 0;
22 | color: #555;
23 | }
24 |
25 | .account-info-item .value {
26 | color: #1f2937;
27 | font-weight: 400;
28 | }
29 |
30 | /* 加载中占位符样式 */
31 | .loading-placeholder {
32 | display: inline-block;
33 | width: 80px;
34 | height: 14px;
35 | background: linear-gradient(90deg, #f0f0f0 25%, #e0e0e0 50%, #f0f0f0 75%);
36 | background-size: 200% 100%;
37 | animation: loading 1.5s infinite;
38 | border-radius: 4px;
39 | }
40 |
41 | @keyframes loading {
42 | 0% {
43 | background-position: 200% 0;
44 | }
45 | 100% {
46 | background-position: -200% 0;
47 | }
48 | }
49 |
50 | /* 菜单编辑弹窗样式 */
51 | .menu-edit-popup {
52 | border-radius: 12px;
53 | padding: 24px;
54 | max-width: 500px;
55 | box-shadow: 0 4px 20px rgba(0, 0, 0, 0.1);
56 | }
57 |
58 | .menu-edit-title {
59 | font-size: 1.5em;
60 | color: #1f2937;
61 | margin-bottom: 24px;
62 | padding-bottom: 16px;
63 | border-bottom: 2px solid #f3f4f6;
64 | font-weight: 600;
65 | }
66 |
67 | .menu-edit-container {
68 | text-align: left;
69 | }
70 |
71 | .menu-edit-container .form-group {
72 | margin-bottom: 24px;
73 | }
74 |
75 | .menu-edit-container label {
76 | display: block;
77 | margin-bottom: 8px;
78 | color: #4b5563;
79 | font-weight: 500;
80 | font-size: 0.95em;
81 | }
82 |
83 | .menu-edit-container .swal2-input,
84 | .menu-edit-container .swal2-select {
85 | width: 100%;
86 | padding: 10px 14px;
87 | border: 2px solid #e5e7eb;
88 | border-radius: 8px;
89 | font-size: 14px;
90 | transition: all 0.3s ease;
91 | background-color: #f9fafb;
92 | }
93 |
94 | .menu-edit-container .swal2-input:hover,
95 | .menu-edit-container .swal2-select:hover {
96 | border-color: #d1d5db;
97 | background-color: #ffffff;
98 | }
99 |
100 | .menu-edit-container .swal2-input:focus,
101 | .menu-edit-container .swal2-select:focus {
102 | border-color: #4CAF50;
103 | outline: none;
104 | box-shadow: 0 0 0 3px rgba(76, 175, 80, 0.1);
105 | background-color: #ffffff;
106 | }
107 |
108 | .menu-edit-confirm {
109 | background-color: #4CAF50 !important;
110 | padding: 10px 24px !important;
111 | border-radius: 8px !important;
112 | font-weight: 500 !important;
113 | transition: all 0.3s ease !important;
114 | font-size: 14px !important;
115 | display: inline-flex !important;
116 | align-items: center !important;
117 | gap: 8px !important;
118 | }
119 |
120 | .menu-edit-confirm:hover {
121 | background-color: #45a049 !important;
122 | transform: translateY(-1px);
123 | box-shadow: 0 2px 8px rgba(76, 175, 80, 0.2);
124 | }
125 |
126 | .menu-edit-cancel {
127 | background-color: #f3f4f6 !important;
128 | color: #4b5563 !important;
129 | padding: 10px 24px !important;
130 | border-radius: 8px !important;
131 | font-weight: 500 !important;
132 | transition: all 0.3s ease !important;
133 | font-size: 14px !important;
134 | display: inline-flex !important;
135 | align-items: center !important;
136 | gap: 8px !important;
137 | }
138 |
139 | .menu-edit-cancel:hover {
140 | background-color: #e5e7eb !important;
141 | transform: translateY(-1px);
142 | box-shadow: 0 2px 8px rgba(0, 0, 0, 0.1);
143 | }
144 |
145 | /* 操作按钮样式优化 */
146 | .action-buttons {
147 | display: flex;
148 | gap: 8px;
149 | justify-content: flex-end;
150 | }
151 |
152 | .action-btn {
153 | width: 32px;
154 | height: 32px;
155 | border-radius: 6px;
156 | border: none;
157 | background-color: #f3f4f6;
158 | color: #4b5563;
159 | cursor: pointer;
160 | display: flex;
161 | align-items: center;
162 | justify-content: center;
163 | transition: all 0.2s ease;
164 | }
165 |
166 | .action-btn:hover {
167 | background-color: #e5e7eb;
168 | transform: translateY(-1px);
169 | }
170 |
171 | .action-btn i {
172 | font-size: 14px;
173 | }
174 |
175 | .action-btn.edit-btn {
176 | color: #3b82f6;
177 | }
178 |
179 | .action-btn.edit-btn:hover {
180 | background-color: #dbeafe;
181 | }
182 |
183 | .action-btn.delete-btn {
184 | color: #ef4444;
185 | }
186 |
187 | .action-btn.delete-btn:hover {
188 | background-color: #fee2e2;
189 | }
190 |
191 | .action-btn.log-btn {
192 | color: #10b981;
193 | }
194 |
195 | .action-btn.log-btn:hover {
196 | background-color: #d1fae5;
197 | }
198 |
199 | .action-btn.start-btn {
200 | color: #10b981;
201 | }
202 |
203 | .action-btn.start-btn:hover {
204 | background-color: #d1fae5;
205 | }
206 |
207 | .action-btn.stop-btn {
208 | color: #ef4444;
209 | }
210 |
211 | .action-btn.stop-btn:hover {
212 | background-color: #fee2e2;
213 | }
214 |
215 | .action-btn.restart-btn {
216 | color: #f59e0b;
217 | }
218 |
219 | .action-btn.restart-btn:hover {
220 | background-color: #fef3c7;
221 | }
222 |
223 | /* Docker 状态指示器样式 */
224 | .status-indicator {
225 | display: inline-flex;
226 | align-items: center;
227 | padding: 6px 12px;
228 | border-radius: 4px;
229 | font-size: 14px;
230 | font-weight: 500;
231 | transition: all 0.3s;
232 | }
233 |
234 | .status-indicator.running {
235 | background-color: rgba(76, 175, 80, 0.1);
236 | color: #4CAF50;
237 | }
238 |
239 | .status-indicator.stopped {
240 | background-color: rgba(244, 67, 54, 0.1);
241 | color: #F44336;
242 | }
243 |
244 | .status-indicator i {
245 | margin-right: 6px;
246 | font-size: 16px;
247 | }
248 |
249 | /* 文档操作按钮样式优化 */
250 | .view-btn {
251 | background-color: #f0f9ff !important;
252 | color: #0ea5e9 !important;
253 | }
254 |
255 | .view-btn:hover {
256 | background-color: #e0f2fe !important;
257 | color: #0284c7 !important;
258 | }
259 |
260 | .edit-btn {
261 | background-color: #f0fdf4 !important;
262 | color: #22c55e !important;
263 | }
264 |
265 | .edit-btn:hover {
266 | background-color: #dcfce7 !important;
267 | color: #16a34a !important;
268 | }
269 |
270 | .delete-btn {
271 | background-color: #fef2f2 !important;
272 | color: #ef4444 !important;
273 | }
274 |
275 | .delete-btn:hover {
276 | background-color: #fee2e2 !important;
277 | color: #dc2626 !important;
278 | }
279 |
280 | .publish-btn {
281 | background-color: #f0fdfa !important;
282 | color: #14b8a6 !important;
283 | }
284 |
285 | .publish-btn:hover {
286 | background-color: #ccfbf1 !important;
287 | color: #0d9488 !important;
288 | }
289 |
290 | .unpublish-btn {
291 | background-color: #fffbeb !important;
292 | color: #f59e0b !important;
293 | }
294 |
295 | .unpublish-btn:hover {
296 | background-color: #fef3c7 !important;
297 | color: #d97706 !important;
298 | }
299 |
300 | /* 刷新按钮交互反馈 */
301 | .refresh-btn {
302 | background-color: #f9fafb;
303 | color: #4b5563;
304 | border: 1px solid #e5e7eb;
305 | padding: 6px 12px;
306 | border-radius: 4px;
307 | display: inline-flex;
308 | align-items: center;
309 | gap: 6px;
310 | font-size: 14px;
311 | cursor: pointer;
312 | transition: all 0.2s ease;
313 | }
314 |
315 | .refresh-btn:hover {
316 | background-color: #f3f4f6;
317 | color: #374151;
318 | }
319 |
320 | .refresh-btn.loading {
321 | pointer-events: none;
322 | opacity: 0.7;
323 | }
324 |
325 | .refresh-btn.loading i {
326 | animation: spin 1s linear infinite;
327 | }
328 |
329 | @keyframes spin {
330 | 0% { transform: rotate(0deg); }
331 | 100% { transform: rotate(360deg); }
332 | }
333 |
334 | /* Docker未运行友好提示 */
335 | .docker-offline-container {
336 | background-color: #f9fafb;
337 | border: 1px solid #e5e7eb;
338 | border-radius: 8px;
339 | padding: 24px;
340 | margin: 20px 0;
341 | text-align: center;
342 | }
343 |
344 | .docker-offline-icon {
345 | font-size: 40px;
346 | color: #9ca3af;
347 | margin-bottom: 16px;
348 | }
349 |
350 | .docker-offline-title {
351 | font-size: 20px;
352 | font-weight: 600;
353 | color: #4b5563;
354 | margin-bottom: 8px;
355 | }
356 |
357 | .docker-offline-message {
358 | color: #6b7280;
359 | margin-bottom: 20px;
360 | }
361 |
362 | .docker-offline-actions {
363 | display: flex;
364 | justify-content: center;
365 | gap: 12px;
366 | }
367 |
368 | .docker-offline-btn {
369 | padding: 8px 16px;
370 | border-radius: 4px;
371 | border: none;
372 | font-weight: 500;
373 | cursor: pointer;
374 | display: inline-flex;
375 | align-items: center;
376 | gap: 8px;
377 | transition: all 0.2s ease;
378 | }
379 |
380 | .docker-offline-btn.primary {
381 | background-color: #4f46e5;
382 | color: white;
383 | }
384 |
385 | .docker-offline-btn.primary:hover {
386 | background-color: #4338ca;
387 | }
388 |
389 | .docker-offline-btn.secondary {
390 | background-color: #f3f4f6;
391 | color: #4b5563;
392 | }
393 |
394 | .docker-offline-btn.secondary:hover {
395 | background-color: #e5e7eb;
396 | }
397 |
--------------------------------------------------------------------------------
/hubcmdui/web/data/documentation/index.json:
--------------------------------------------------------------------------------
1 | []
--------------------------------------------------------------------------------
/hubcmdui/web/images/login-bg.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dqzboy/Docker-Proxy/04cfa607b87f46acd6f8904f6e0be96ab6057b45/hubcmdui/web/images/login-bg.jpg
--------------------------------------------------------------------------------
/hubcmdui/web/js/auth.js:
--------------------------------------------------------------------------------
1 | // 用户认证相关功能
2 |
3 | // 登录函数
4 | async function login() {
5 | const username = document.getElementById('username').value;
6 | const password = document.getElementById('password').value;
7 | const captcha = document.getElementById('captcha').value;
8 |
9 | try {
10 | core.showLoading();
11 | const response = await fetch('/api/login', {
12 | method: 'POST',
13 | headers: { 'Content-Type': 'application/json' },
14 | body: JSON.stringify({ username, password, captcha })
15 | });
16 |
17 | if (response.ok) {
18 | const data = await response.json();
19 |
20 | window.isLoggedIn = true;
21 | localStorage.setItem('isLoggedIn', 'true');
22 | persistSession();
23 | document.getElementById('currentUsername').textContent = username;
24 | document.getElementById('welcomeUsername').textContent = username;
25 | document.getElementById('loginModal').style.display = 'none';
26 | document.getElementById('adminContainer').style.display = 'flex';
27 |
28 | // 确保加载完成后初始化事件监听器
29 | await core.loadSystemConfig();
30 | core.initEventListeners();
31 | core.showSection('dashboard');
32 | userCenter.getUserInfo();
33 | systemStatus.refreshSystemStatus();
34 | } else {
35 | const errorData = await response.json();
36 | core.showAlert(errorData.error || '登录失败', 'error');
37 | refreshCaptcha();
38 | }
39 | } catch (error) {
40 | core.showAlert('登录失败: ' + error.message, 'error');
41 | refreshCaptcha();
42 | } finally {
43 | core.hideLoading();
44 | }
45 | }
46 |
47 | // 注销函数
48 | async function logout() {
49 | // console.log("注销操作被触发");
50 | try {
51 | core.showLoading();
52 | const response = await fetch('/api/logout', { method: 'POST' });
53 | if (response.ok) {
54 | // 清除所有登录状态
55 | localStorage.removeItem('isLoggedIn');
56 | sessionStorage.removeItem('sessionActive');
57 | window.isLoggedIn = false;
58 | // 清除cookie
59 | document.cookie = 'connect.sid=; expires=Thu, 01 Jan 1970 00:00:00 UTC; path=/;';
60 | window.location.reload();
61 | } else {
62 | throw new Error('退出登录失败');
63 | }
64 | } catch (error) {
65 | // console.error('退出登录失败:', error);
66 | core.showAlert('退出登录失败: ' + error.message, 'error');
67 | // 即使API失败也清除本地状态
68 | localStorage.removeItem('isLoggedIn');
69 | sessionStorage.removeItem('sessionActive');
70 | window.isLoggedIn = false;
71 | window.location.reload();
72 | } finally {
73 | core.hideLoading();
74 | }
75 | }
76 |
77 | // 验证码刷新函数
78 | async function refreshCaptcha() {
79 | try {
80 | const response = await fetch('/api/captcha');
81 | if (!response.ok) {
82 | throw new Error(`验证码获取失败: ${response.status}`);
83 | }
84 | const data = await response.json();
85 | document.getElementById('captchaText').textContent = data.captcha;
86 | } catch (error) {
87 | // console.error('刷新验证码失败:', error);
88 | document.getElementById('captchaText').textContent = '验证码加载失败，点击重试';
89 | }
90 | }
91 |
92 | // 持久化会话
93 | function persistSession() {
94 | if (document.cookie.includes('connect.sid')) {
95 | sessionStorage.setItem('sessionActive', 'true');
96 | }
97 | }
98 |
99 | // 显示登录模态框
100 | function showLoginModal() {
101 | // 确保先隐藏加载指示器
102 | if (core && typeof core.hideLoadingIndicator === 'function') {
103 | core.hideLoadingIndicator();
104 | }
105 |
106 | document.getElementById('loginModal').style.display = 'flex';
107 | refreshCaptcha();
108 | }
109 |
110 | // 导出模块
111 | const auth = {
112 | init: function() {
113 | // console.log('初始化认证模块...');
114 | // 在这里可以添加认证模块初始化的相关代码
115 | return Promise.resolve(); // 返回一个已解决的 Promise，保持与其他模块一致
116 | },
117 | login,
118 | logout,
119 | refreshCaptcha,
120 | showLoginModal
121 | };
122 |
123 | // 全局公开认证模块
124 | window.auth = auth;
125 |
--------------------------------------------------------------------------------
/hubcmdui/web/js/error-handler.js:
--------------------------------------------------------------------------------
1 | // 客户端错误收集器
2 |
3 | (function() {
4 | // 保存原始控制台方法
5 | const originalConsoleError = console.error;
6 |
7 | // 重写console.error以捕获错误
8 | console.error = function(...args) {
9 | // 调用原始方法
10 | originalConsoleError.apply(console, args);
11 |
12 | // 提取错误信息
13 | const errorMessage = args.map(arg => {
14 | if (arg instanceof Error) {
15 | return arg.stack || arg.message;
16 | } else if (typeof arg === 'object') {
17 | try {
18 | return JSON.stringify(arg);
19 | } catch (e) {
20 | return String(arg);
21 | }
22 | } else {
23 | return String(arg);
24 | }
25 | }).join(' ');
26 |
27 | // 向服务器报告错误
28 | reportErrorToServer({
29 | message: errorMessage,
30 | source: 'console.error',
31 | type: 'console'
32 | });
33 | };
34 |
35 | // 全局错误处理
36 | window.addEventListener('error', function(event) {
37 | reportErrorToServer({
38 | message: event.message,
39 | source: event.filename,
40 | lineno: event.lineno,
41 | colno: event.colno,
42 | stack: event.error ? event.error.stack : null,
43 | type: 'uncaught'
44 | });
45 | });
46 |
47 | // Promise错误处理
48 | window.addEventListener('unhandledrejection', function(event) {
49 | const message = event.reason instanceof Error
50 | ? event.reason.message
51 | : String(event.reason);
52 |
53 | const stack = event.reason instanceof Error
54 | ? event.reason.stack
55 | : null;
56 |
57 | reportErrorToServer({
58 | message: message,
59 | stack: stack,
60 | type: 'promise'
61 | });
62 | });
63 |
64 | // 向服务器发送错误报告
65 | function reportErrorToServer(errorData) {
66 | // 添加额外信息
67 | const data = {
68 | ...errorData,
69 | userAgent: navigator.userAgent,
70 | page: window.location.href,
71 | timestamp: new Date().toISOString()
72 | };
73 |
74 | // 发送错误报告到服务器
75 | fetch('/api/client-error', {
76 | method: 'POST',
77 | headers: { 'Content-Type': 'application/json' },
78 | body: JSON.stringify(data),
79 | // 使用keepalive以确保在页面卸载时仍能发送
80 | keepalive: true
81 | }).catch(err => {
82 | // 不记录这个错误，避免无限循环
83 | });
84 | }
85 | })();
86 |
--------------------------------------------------------------------------------
/hubcmdui/web/js/nav-menu.js:
--------------------------------------------------------------------------------
1 | /**
2 | * 导航菜单加载模块
3 | * 负责从config加载并渲染前端导航菜单
4 | */
5 |
6 | // 用于跟踪菜单是否已加载
7 | let menuLoaded = false;
8 |
9 | // 立即执行初始化函数
10 | (function() {
11 | // console.log('[菜单模块] 初始化开始');
12 | try {
13 | // 页面加载完成后执行，但不在这里调用加载函数
14 | document.addEventListener('DOMContentLoaded', function() {
15 | // console.log('[菜单模块] DOM内容加载完成，等待loadMenu或loadNavMenu调用');
16 | // 不在这里调用，避免重复加载
17 | });
18 | // console.log('[菜单模块] 初始化完成，等待调用');
19 | } catch (error) {
20 | console.error('[菜单模块] 初始化失败:', error);
21 | }
22 | })();
23 |
24 | // 加载导航菜单
25 | async function loadNavMenu() {
26 | if (menuLoaded) {
27 | // console.log('[菜单模块] 菜单已加载，跳过');
28 | return;
29 | }
30 |
31 | // console.log('[菜单模块] loadNavMenu() 函数被调用');
32 | const navMenu = document.getElementById('navMenu');
33 | if (!navMenu) {
34 | console.error('[菜单模块] 无法找到id为navMenu的元素，菜单加载失败');
35 | return;
36 | }
37 |
38 | try {
39 | // console.log('[菜单模块] 正在从/api/config获取菜单配置...');
40 |
41 | // 从API获取配置
42 | const response = await fetch('/api/config');
43 | // console.log('[菜单模块] API响应状态:', response.status, response.statusText);
44 |
45 | if (!response.ok) {
46 | throw new Error(`获取配置失败: ${response.status} ${response.statusText}`);
47 | }
48 |
49 | const config = await response.json();
50 | // console.log('[菜单模块] 成功获取配置:', config);
51 |
52 | // 确保menuItems存在且是数组
53 | if (!config.menuItems || !Array.isArray(config.menuItems) || config.menuItems.length === 0) {
54 | console.warn('[菜单模块] 配置中没有菜单项或格式不正确', config);
55 | navMenu.innerHTML = '';
56 | menuLoaded = true;
57 | return;
58 | }
59 |
60 | // 渲染菜单
61 | renderNavMenu(navMenu, config.menuItems);
62 | menuLoaded = true;
63 |
64 | } catch (error) {
65 | console.error('[菜单模块] 加载导航菜单失败:', error);
66 | navMenu.innerHTML = ``;
67 | }
68 | }
69 |
70 | // 渲染导航菜单
71 | function renderNavMenu(navMenuElement, menuItems) {
72 | try {
73 | // console.log('[菜单模块] 开始渲染导航菜单，菜单项数量:', menuItems.length);
74 |
75 | // 清空现有内容
76 | navMenuElement.innerHTML = '';
77 |
78 | // 移动设备菜单切换按钮
79 | const menuToggle = document.createElement('div');
80 | menuToggle.id = 'menuToggle';
81 | menuToggle.className = 'menu-toggle';
82 | menuToggle.innerHTML = '请选择参数并开始测试。
';
17 | }
18 | },
19 |
20 | // 初始化网络测试界面控件和事件
21 | initNetworkTestControls: function() {
22 | const domainSelect = document.getElementById('domainSelect');
23 | const testTypeSelect = document.getElementById('testType'); // Corrected ID reference
24 | const startTestButton = document.getElementById('startTestBtn'); // Use ID
25 | const clearResultsButton = document.getElementById('clearTestResultsBtn');
26 | const resultsDiv = document.getElementById('testResults');
27 |
28 | // 填充域名选择器
29 | if (domainSelect) {
30 | domainSelect.innerHTML = `
31 | 选择预定义域名
32 | gcr.io
33 | ghcr.io
34 | quay.io
35 | k8s.gcr.io
36 | registry.k8s.io
37 | mcr.microsoft.com
38 | docker.elastic.co
39 | registry-1.docker.io
40 | google.com (测试用)
41 | cloudflare.com (测试用)
42 | 自定义域名
43 | `;
44 |
45 | // 添加选择变化事件，显示/隐藏自定义域名输入框
46 | domainSelect.addEventListener('change', () => {
47 | const customDomainContainer = document.getElementById('customDomainContainer');
48 | if (customDomainContainer) {
49 | customDomainContainer.style.display = domainSelect.value === 'custom' ? 'block' : 'none';
50 | }
51 | });
52 | }
53 |
54 | // 填充测试类型选择器
55 | if (testTypeSelect) {
56 | testTypeSelect.innerHTML = `
57 | Ping (ICMP)
58 | Traceroute
59 | `;
60 | }
61 |
62 | // 绑定开始测试按钮点击事件
63 | if (startTestButton) {
64 | // Bind the function correctly, preserving 'this' context if necessary,
65 | // or ensure runNetworkTest doesn't rely on 'this' from the event handler.
66 | // Using an arrow function or .bind(this) if runNetworkTest uses 'this.someOtherMethod'
67 | startTestButton.addEventListener('click', () => this.runNetworkTest());
68 | } else {
69 | // console.error('未找到开始测试按钮 (ID: startTestBtn)');
70 | }
71 |
72 | // 绑定清空结果按钮点击事件
73 | if (clearResultsButton && resultsDiv) {
74 | clearResultsButton.addEventListener('click', () => {
75 | resultsDiv.innerHTML = '结果已清空。
';
76 | // Optionally, remove loading class if it was somehow stuck
77 | resultsDiv.classList.remove('loading');
78 | });
79 | } else {
80 | if (!clearResultsButton) { /* console.error('未找到清空结果按钮 (ID: clearTestResultsBtn)'); */ }
81 | if (!resultsDiv) { /* console.error('未找到测试结果区域 (ID: testResults)'); */ }
82 | }
83 | },
84 |
85 | // 运行网络测试
86 | runNetworkTest: async function() { // Changed to async for await
87 | let domain = document.getElementById('domainSelect').value;
88 | const testType = document.getElementById('testType').value;
89 | const resultsDiv = document.getElementById('testResults');
90 | const startTestButton = document.getElementById('startTestBtn');
91 |
92 | // 处理自定义域名
93 | if (domain === 'custom') {
94 | const customDomain = document.getElementById('customDomain')?.value?.trim();
95 | if (!customDomain) {
96 | core.showAlert('请输入自定义域名进行测试。', 'warning');
97 | return;
98 | }
99 | domain = customDomain;
100 | } else if (!domain) {
101 | core.showAlert('请选择目标域名进行测试。', 'warning');
102 | return;
103 | }
104 |
105 | if (!testType) {
106 | core.showAlert('请选择测试类型。', 'warning');
107 | return;
108 | }
109 |
110 | resultsDiv.innerHTML = ''; // Clear previous content before adding loading class
111 | resultsDiv.classList.add('loading');
112 | if(startTestButton) startTestButton.disabled = true; // Disable button during test
113 |
114 | const controller = new AbortController();
115 | const timeoutId = setTimeout(() => {
116 | controller.abort();
117 | // logger.warn('Network test aborted due to timeout.');
118 | }, 60000); // 60秒超时
119 |
120 | try {
121 | const response = await fetch('/api/network-test', {
122 | method: 'POST',
123 | headers: {
124 | 'Content-Type': 'application/json',
125 | // Add any necessary auth headers if your API requires them
126 | // 'Authorization': 'Bearer ' + localStorage.getItem('authToken'),
127 | },
128 | body: JSON.stringify({ domain, type: testType }),
129 | signal: controller.signal
130 | });
131 |
132 | clearTimeout(timeoutId);
133 |
134 | if (!response.ok) {
135 | const errorText = await response.text();
136 | let detail = errorText;
137 | try {
138 | const errorJson = JSON.parse(errorText);
139 | detail = errorJson.message || errorJson.error || errorText;
140 | } catch (e) { /* ignore parsing error, use raw text */ }
141 | throw new Error(`网络连接正常，但测试执行失败 (状态: ${response.status}): ${detail}`);
142 | }
143 | const result = await response.text();
144 | // Format the plain text result in a tag for better display
145 | resultsDiv.innerHTML = `${result} `;
146 | } catch (error) {
147 | clearTimeout(timeoutId); // Ensure timeout is cleared on any error
148 | // console.error('网络测试出错:', error);
149 | let errorMessage = '测试失败: ' + error.message;
150 | if (error.name === 'AbortError') {
151 | errorMessage = '测试请求超时 (60秒)。请检查网络连接或目标主机状态。';
152 | }
153 | resultsDiv.innerHTML = `${errorMessage} `;
154 | } finally {
155 | resultsDiv.classList.remove('loading');
156 | if(startTestButton) startTestButton.disabled = false; // Re-enable button
157 | }
158 | }
159 | };
160 |
161 | // 全局公开网络测试模块 (或者 integrate with app.js module system if you have one)
162 | // Ensure this is called after the DOM is ready, e.g., in app.js or a DOMContentLoaded listener
163 | // For now, let's assume app.js handles calling networkTest.init()
164 | window.networkTest = networkTest;
165 |
--------------------------------------------------------------------------------
/hubcmdui/web/services/documentationService.js:
--------------------------------------------------------------------------------
1 | const fs = require('fs');
2 | const path = require('path');
3 | const { v4: uuidv4 } = require('uuid');
4 |
5 | // 文档存储目录
6 | const DOCUMENTATION_DIR = path.join(__dirname, '..', 'data', 'documentation');
7 |
8 | /**
9 | * 确保文档目录存在
10 | */
11 | async function ensureDocumentationDirExists() {
12 | if (!fs.existsSync(DOCUMENTATION_DIR)) {
13 | await fs.promises.mkdir(DOCUMENTATION_DIR, { recursive: true });
14 | console.log(`创建文档目录: ${DOCUMENTATION_DIR}`);
15 | }
16 | }
17 |
18 | /**
19 | * 获取文档列表
20 | * @returns {Promise} 文档列表
21 | */
22 | async function getDocumentList() {
23 | try {
24 | await ensureDocumentationDirExists();
25 |
26 | // 检查索引文件是否存在
27 | const indexPath = path.join(DOCUMENTATION_DIR, 'index.json');
28 | if (!fs.existsSync(indexPath)) {
29 | // 创建空索引，不再添加默认文档
30 | await fs.promises.writeFile(indexPath, JSON.stringify([]), 'utf8');
31 | console.log('创建了空的文档索引文件');
32 | return [];
33 | }
34 |
35 | // 读取索引文件
36 | const data = await fs.promises.readFile(indexPath, 'utf8');
37 | return JSON.parse(data || '[]');
38 | } catch (error) {
39 | console.error('获取文档列表失败:', error);
40 | return [];
41 | }
42 | }
43 |
44 | /**
45 | * 保存文档列表
46 | * @param {Array} docList 文档列表
47 | */
48 | async function saveDocumentList(docList) {
49 | try {
50 | await ensureDocumentationDirExists();
51 |
52 | const indexPath = path.join(DOCUMENTATION_DIR, 'index.json');
53 | await fs.promises.writeFile(indexPath, JSON.stringify(docList, null, 2), 'utf8');
54 | console.log('文档列表已更新');
55 | } catch (error) {
56 | console.error('保存文档列表失败:', error);
57 | throw error;
58 | }
59 | }
60 |
61 | /**
62 | * 获取单个文档的内容
63 | * @param {string} docId 文档ID
64 | * @returns {Promise} 文档内容
65 | */
66 | async function getDocumentContent(docId) {
67 | try {
68 | console.log(`尝试获取文档内容，ID: ${docId}`);
69 |
70 | // 确保文档目录存在
71 | await ensureDocumentationDirExists();
72 |
73 | // 获取文档列表
74 | const docList = await getDocumentList();
75 | const doc = docList.find(doc => doc.id === docId || doc._id === docId);
76 |
77 | if (!doc) {
78 | throw new Error(`文档不存在，ID: ${docId}`);
79 | }
80 |
81 | // 构建文档路径
82 | const docPath = path.join(DOCUMENTATION_DIR, `${docId}.md`);
83 |
84 | // 检查文件是否存在
85 | if (!fs.existsSync(docPath)) {
86 | return ''; // 文件不存在，返回空内容
87 | }
88 |
89 | // 读取文档内容
90 | const content = await fs.promises.readFile(docPath, 'utf8');
91 | console.log(`成功读取文档内容，ID: ${docId}, 内容长度: ${content.length}`);
92 |
93 | return content;
94 | } catch (error) {
95 | console.error(`获取文档内容失败，ID: ${docId}`, error);
96 | throw error;
97 | }
98 | }
99 |
100 | /**
101 | * 创建或更新文档
102 | * @param {Object} doc 文档对象
103 | * @param {string} content 文档内容
104 | * @returns {Promise} 保存后的文档
105 | */
106 | async function saveDocument(doc, content) {
107 | try {
108 | await ensureDocumentationDirExists();
109 |
110 | // 获取现有文档列表
111 | const docList = await getDocumentList();
112 |
113 | // 为新文档生成ID
114 | if (!doc.id) {
115 | doc.id = uuidv4();
116 | }
117 |
118 | // 更新文档元数据
119 | doc.lastUpdated = new Date().toISOString();
120 |
121 | // 查找现有文档索引
122 | const existingIndex = docList.findIndex(item => item.id === doc.id);
123 |
124 | if (existingIndex >= 0) {
125 | // 更新现有文档
126 | docList[existingIndex] = { ...docList[existingIndex], ...doc };
127 | } else {
128 | // 添加新文档
129 | docList.push(doc);
130 | }
131 |
132 | // 保存文档内容
133 | const docPath = path.join(DOCUMENTATION_DIR, `${doc.id}.md`);
134 | await fs.promises.writeFile(docPath, content || '', 'utf8');
135 |
136 | // 更新文档列表
137 | await saveDocumentList(docList);
138 |
139 | return doc;
140 | } catch (error) {
141 | console.error('保存文档失败:', error);
142 | throw error;
143 | }
144 | }
145 |
146 | /**
147 | * 删除文档
148 | * @param {string} docId 文档ID
149 | * @returns {Promise} 删除结果
150 | */
151 | async function deleteDocument(docId) {
152 | try {
153 | await ensureDocumentationDirExists();
154 |
155 | // 获取现有文档列表
156 | const docList = await getDocumentList();
157 |
158 | // 查找文档索引
159 | const existingIndex = docList.findIndex(doc => doc.id === docId);
160 |
161 | if (existingIndex === -1) {
162 | return false; // 文档不存在
163 | }
164 |
165 | // 从列表中移除
166 | docList.splice(existingIndex, 1);
167 |
168 | // 删除文档文件
169 | const docPath = path.join(DOCUMENTATION_DIR, `${docId}.md`);
170 | if (fs.existsSync(docPath)) {
171 | await fs.promises.unlink(docPath);
172 | }
173 |
174 | // 更新文档列表
175 | await saveDocumentList(docList);
176 |
177 | return true;
178 | } catch (error) {
179 | console.error('删除文档失败:', error);
180 | throw error;
181 | }
182 | }
183 |
184 | /**
185 | * 发布或取消发布文档
186 | * @param {string} docId 文档ID
187 | * @param {boolean} publishState 发布状态
188 | * @returns {Promise} 更新后的文档
189 | */
190 | async function togglePublishState(docId, publishState) {
191 | try {
192 | // 获取现有文档列表
193 | const docList = await getDocumentList();
194 |
195 | // 查找文档索引
196 | const existingIndex = docList.findIndex(doc => doc.id === docId);
197 |
198 | if (existingIndex === -1) {
199 | throw new Error('文档不存在');
200 | }
201 |
202 | // 更新发布状态
203 | docList[existingIndex].published = !!publishState;
204 | docList[existingIndex].lastUpdated = new Date().toISOString();
205 |
206 | // 更新文档列表
207 | await saveDocumentList(docList);
208 |
209 | return docList[existingIndex];
210 | } catch (error) {
211 | console.error('更新文档发布状态失败:', error);
212 | throw error;
213 | }
214 | }
215 |
216 | module.exports = {
217 | ensureDocumentationDirExists,
218 | getDocumentList,
219 | saveDocumentList,
220 | getDocumentContent,
221 | saveDocument,
222 | deleteDocument,
223 | togglePublishState
224 | };
--------------------------------------------------------------------------------
