@lzwme/sserver 0.0.10 → 1.0.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/LICENSE +21 -21
- package/README.MD +72 -100
- package/bin/sserver.js +0 -0
- package/dist/assets/assets/localsend/style.css +2 -0
- package/dist/assets/assets/localsend/vendor/qr-code-styling.js +2 -0
- package/dist/assets/localsend/style.css +2 -0
- package/dist/assets/localsend/vendor/qr-code-styling.js +2 -0
- package/dist/cli.js +26 -4
- package/dist/config.d.ts +38 -1
- package/dist/config.js +54 -9
- package/dist/lib/get-cert.js +1 -1
- package/dist/lib/merge-config.d.ts +9 -0
- package/dist/lib/merge-config.js +66 -0
- package/dist/lib/utils.d.ts +27 -1
- package/dist/lib/utils.js +94 -14
- package/dist/localsend/audit.d.ts +36 -0
- package/dist/localsend/audit.js +104 -0
- package/dist/localsend/auth.d.ts +94 -0
- package/dist/localsend/auth.js +227 -0
- package/dist/localsend/cache.d.ts +34 -0
- package/dist/localsend/cache.js +269 -0
- package/dist/localsend/chunk.d.ts +114 -0
- package/dist/localsend/chunk.js +475 -0
- package/dist/localsend/cleaner.d.ts +19 -0
- package/dist/localsend/cleaner.js +80 -0
- package/dist/localsend/client/app.js +4131 -0
- package/dist/localsend/client/crypto.js +233 -0
- package/dist/localsend/client/favicon.png +0 -0
- package/dist/localsend/client/icons/icon-192.png +0 -0
- package/dist/localsend/client/icons/icon-512.png +0 -0
- package/dist/localsend/client/index.html +451 -0
- package/dist/localsend/client/manifest.webmanifest +33 -0
- package/dist/localsend/client/sw.js +128 -0
- package/dist/localsend/guard.d.ts +58 -0
- package/dist/localsend/guard.js +210 -0
- package/dist/localsend/index.d.ts +52 -0
- package/dist/localsend/index.js +1771 -0
- package/dist/localsend/manage.d.ts +96 -0
- package/dist/localsend/manage.js +304 -0
- package/dist/localsend/metrics.d.ts +26 -0
- package/dist/localsend/metrics.js +58 -0
- package/dist/localsend/paste.d.ts +72 -0
- package/dist/localsend/paste.js +125 -0
- package/dist/localsend/path.d.ts +33 -0
- package/dist/localsend/path.js +151 -0
- package/dist/localsend/query.d.ts +78 -0
- package/dist/localsend/query.js +147 -0
- package/dist/localsend/secret.d.ts +31 -0
- package/dist/localsend/secret.js +96 -0
- package/dist/localsend/settings.d.ts +53 -0
- package/dist/localsend/settings.js +285 -0
- package/dist/localsend/share.d.ts +35 -0
- package/dist/localsend/share.js +117 -0
- package/dist/localsend/temp.d.ts +10 -0
- package/dist/localsend/temp.js +47 -0
- package/dist/localsend/ticket.d.ts +40 -0
- package/dist/localsend/ticket.js +98 -0
- package/dist/localsend/trash.d.ts +39 -0
- package/dist/localsend/trash.js +261 -0
- package/dist/localsend/webdav.d.ts +50 -0
- package/dist/localsend/webdav.js +530 -0
- package/dist/localsend/zip.d.ts +20 -0
- package/dist/localsend/zip.js +186 -0
- package/dist/proxy/php-proxy.js +54 -21
- package/dist/static-server.js +10 -3
- package/package.json +21 -13
- package/dist/localsend/index.html +0 -481
- package/dist/localsend.d.ts +0 -2
- package/dist/localsend.js +0 -148
|
@@ -0,0 +1,1771 @@
|
|
|
1
|
+
"use strict";
|
|
2
|
+
/*
|
|
3
|
+
* LocalSend 局域网文件传输服务端模块
|
|
4
|
+
* 路由:
|
|
5
|
+
* - GET /localsend 页面
|
|
6
|
+
* - GET /localsend/api/list 文件列表(分页 + 搜索 + 筛选 + 排序)
|
|
7
|
+
* - GET /localsend/api/facets 筛选选项(目录 / 扩展名及各自条目数)
|
|
8
|
+
* - POST /localsend/api/upload 多文件上传(multipart,字段名 files)
|
|
9
|
+
* - GET /localsend/api/download/:name 下载(attachment)
|
|
10
|
+
* - GET /localsend/api/preview/:name 预览(inline)
|
|
11
|
+
* - DELETE /localsend/api/delete/:name 删除
|
|
12
|
+
* - POST /localsend/api/rename 重命名 / 移动单个文件
|
|
13
|
+
* - POST /localsend/api/move 批量移动到指定目录
|
|
14
|
+
* - POST /localsend/api/rename-batch 按规则批量重命名
|
|
15
|
+
*/
|
|
16
|
+
var __importDefault = (this && this.__importDefault) || function (mod) {
|
|
17
|
+
return (mod && mod.__esModule) ? mod : { "default": mod };
|
|
18
|
+
};
|
|
19
|
+
Object.defineProperty(exports, "__esModule", { value: true });
|
|
20
|
+
exports.DEFAULT_BLOCK_EXTENSIONS = void 0;
|
|
21
|
+
exports.resolveAssetsDir = resolveAssetsDir;
|
|
22
|
+
exports.decodeUploadName = decodeUploadName;
|
|
23
|
+
exports.repairLocalsendNames = repairLocalsendNames;
|
|
24
|
+
exports.dirSize = dirSize;
|
|
25
|
+
exports.initLocalsend = initLocalsend;
|
|
26
|
+
const node_crypto_1 = require("node:crypto");
|
|
27
|
+
const node_fs_1 = require("node:fs");
|
|
28
|
+
const node_path_1 = require("node:path");
|
|
29
|
+
const console_log_colors_1 = require("console-log-colors");
|
|
30
|
+
const express_1 = __importDefault(require("express"));
|
|
31
|
+
const multer_1 = __importDefault(require("multer"));
|
|
32
|
+
const config_1 = require("../config");
|
|
33
|
+
const get_logger_1 = require("../get-logger");
|
|
34
|
+
const utils_1 = require("../lib/utils");
|
|
35
|
+
const audit_1 = require("./audit");
|
|
36
|
+
const auth_1 = require("./auth");
|
|
37
|
+
const cache_1 = require("./cache");
|
|
38
|
+
const chunk_1 = require("./chunk");
|
|
39
|
+
const cleaner_1 = require("./cleaner");
|
|
40
|
+
const guard_1 = require("./guard");
|
|
41
|
+
const manage_1 = require("./manage");
|
|
42
|
+
const metrics_1 = require("./metrics");
|
|
43
|
+
const paste_1 = require("./paste");
|
|
44
|
+
const path_1 = require("./path");
|
|
45
|
+
const query_1 = require("./query");
|
|
46
|
+
const secret_1 = require("./secret");
|
|
47
|
+
const settings_1 = require("./settings");
|
|
48
|
+
const share_1 = require("./share");
|
|
49
|
+
const temp_1 = require("./temp");
|
|
50
|
+
const ticket_1 = require("./ticket");
|
|
51
|
+
const trash_1 = require("./trash");
|
|
52
|
+
const webdav_1 = require("./webdav");
|
|
53
|
+
const zip_1 = require("./zip");
|
|
54
|
+
/**
|
|
55
|
+
* 前端页面单文件路径(相对本模块所在目录)。
|
|
56
|
+
*
|
|
57
|
+
* 本模块位于 src/localsend(dev)或 dist/localsend(prod),
|
|
58
|
+
* 页面资源位于同级的 client 目录(src/localsend/client / dist/localsend/client),
|
|
59
|
+
* 两处结构一致,因此用同一条相对路径即可,无需区分开发态与运行态。
|
|
60
|
+
*/
|
|
61
|
+
const PAGE_REL_PATH = './client/index.html';
|
|
62
|
+
/** 页面静态资源目录(相对本模块),与 PAGE_REL_PATH 同级 */
|
|
63
|
+
const PAGE_DIR = './client';
|
|
64
|
+
/**
|
|
65
|
+
* 前端构建产物目录(相对本模块所在目录)。
|
|
66
|
+
*
|
|
67
|
+
* 产物(tailwind 生成的 style.css、vendor 第三方库)刻意不放进源码目录,
|
|
68
|
+
* 避免与源码混在一起造成误解;它们集中存放在仓库根的 assets/ 下,
|
|
69
|
+
* 由构建生成、不纳入版本管理。
|
|
70
|
+
*/
|
|
71
|
+
const ASSETS_REL = 'assets/localsend';
|
|
72
|
+
/**
|
|
73
|
+
* 探测前端构建产物目录。
|
|
74
|
+
*
|
|
75
|
+
* 产物位置随运行方式而变,因此不写死单一路径,而是从运行目录逐级向上找
|
|
76
|
+
* 第一个包含 style.css 的 assets 目录:
|
|
77
|
+
* - 运行态(__dirname 为 dist/localsend):dist 内自带 assets,发布包开箱即用
|
|
78
|
+
* - 开发态(__dirname 为 src/localsend):产物在仓库根 assets/,需上溯两级
|
|
79
|
+
*
|
|
80
|
+
* 逐级探测的好处是:产物目录无论放在运行目录、其上级还是仓库根,
|
|
81
|
+
* 都能被找到;同时不会误取到更外层的无关 assets 目录。
|
|
82
|
+
*
|
|
83
|
+
* 找不到时返回 null,由调用方决定降级处理(给出提示而非直接崩溃)。
|
|
84
|
+
*
|
|
85
|
+
* @param baseDir 运行目录,默认取当前模块所在目录
|
|
86
|
+
*/
|
|
87
|
+
function resolveAssetsDir(baseDir = __dirname) {
|
|
88
|
+
let dir = (0, node_path_1.resolve)(baseDir);
|
|
89
|
+
for (let depth = 0; depth < 5; depth++) {
|
|
90
|
+
const candidate = (0, node_path_1.join)(dir, ASSETS_REL);
|
|
91
|
+
if ((0, node_fs_1.existsSync)((0, node_path_1.join)(candidate, 'style.css')))
|
|
92
|
+
return candidate;
|
|
93
|
+
const parent = (0, node_path_1.dirname)(dir);
|
|
94
|
+
if (parent === dir)
|
|
95
|
+
break;
|
|
96
|
+
dir = parent;
|
|
97
|
+
}
|
|
98
|
+
return null;
|
|
99
|
+
}
|
|
100
|
+
/** 严格解码字节,编码不匹配时返回 null */
|
|
101
|
+
function decodeStrict(bytes, encoding) {
|
|
102
|
+
try {
|
|
103
|
+
return new TextDecoder(encoding, { fatal: true }).decode(bytes);
|
|
104
|
+
}
|
|
105
|
+
catch {
|
|
106
|
+
return null;
|
|
107
|
+
}
|
|
108
|
+
}
|
|
109
|
+
/**
|
|
110
|
+
* 修复 multipart 上传的文件名乱码。
|
|
111
|
+
*
|
|
112
|
+
* 浏览器(WHATWG 规范)会把文件名的 UTF-8 原始字节直接写进 Content-Disposition 的 filename 参数,
|
|
113
|
+
* 而 busboy 默认按 latin1(defParamCharset='latin1')解码该参数,中文文件名就会变成乱码
|
|
114
|
+
* (如 `中文.txt` → `䏿–‡.txt`)。
|
|
115
|
+
*
|
|
116
|
+
* 这里保留原始字节(latin1 与字节一一对应,可无损还原),再按 utf-8 / gb18030 依次尝试严格解码:
|
|
117
|
+
* - UTF-8 是浏览器的标准行为;
|
|
118
|
+
* - gb18030 兼容部分国产客户端 / 老程序用 GBK 发送文件名的情况。
|
|
119
|
+
*/
|
|
120
|
+
function decodeUploadName(raw) {
|
|
121
|
+
const name = String(raw || '');
|
|
122
|
+
if (!name)
|
|
123
|
+
return '';
|
|
124
|
+
// 含有 latin1 之外的字符,说明文件名已被正确解码过(如 RFC2231 的 filename*),直接使用
|
|
125
|
+
if ([...name].some((c) => c.charCodeAt(0) > 255))
|
|
126
|
+
return name;
|
|
127
|
+
const bytes = Buffer.from(name, 'latin1');
|
|
128
|
+
for (const encoding of ['utf-8', 'gb18030']) {
|
|
129
|
+
const decoded = decodeStrict(bytes, encoding);
|
|
130
|
+
if (decoded !== null && decoded !== name)
|
|
131
|
+
return decoded;
|
|
132
|
+
}
|
|
133
|
+
return name;
|
|
134
|
+
}
|
|
135
|
+
/**
|
|
136
|
+
* 修复历史上已上传的乱码文件名(把 UTF-8 字节误存成 latin1 字符导致的乱码)。
|
|
137
|
+
* 返回被重命名的 [旧名, 新名] 列表。
|
|
138
|
+
*/
|
|
139
|
+
function repairLocalsendNames(dir) {
|
|
140
|
+
const renamed = [];
|
|
141
|
+
if (!(0, node_fs_1.existsSync)(dir))
|
|
142
|
+
return renamed;
|
|
143
|
+
for (const name of (0, node_fs_1.readdirSync)(dir)) {
|
|
144
|
+
const full = (0, node_path_1.join)(dir, name);
|
|
145
|
+
if (!(0, node_fs_1.statSync)(full).isFile())
|
|
146
|
+
continue;
|
|
147
|
+
if ([...name].some((c) => c.charCodeAt(0) > 255))
|
|
148
|
+
continue; // 已是正常文件名
|
|
149
|
+
const decoded = decodeStrict(Buffer.from(name, 'latin1'), 'utf-8');
|
|
150
|
+
if (decoded === null || decoded === name)
|
|
151
|
+
continue; // 非乱码
|
|
152
|
+
// 目标名已存在时按 _1/_2 追加后缀,避免覆盖同名文件
|
|
153
|
+
const target = (0, manage_1.uniqueName)(dir, decoded);
|
|
154
|
+
try {
|
|
155
|
+
(0, node_fs_1.renameSync)(full, (0, node_path_1.join)(dir, target));
|
|
156
|
+
renamed.push([name, target]);
|
|
157
|
+
}
|
|
158
|
+
catch (err) {
|
|
159
|
+
get_logger_1.logger.error('[localsend 修复文件名]', err);
|
|
160
|
+
}
|
|
161
|
+
}
|
|
162
|
+
return renamed;
|
|
163
|
+
}
|
|
164
|
+
/** 取请求中的相对路径参数(支持通配符路由) */
|
|
165
|
+
function relParam(req, key = 'name') {
|
|
166
|
+
const value = req.params[key];
|
|
167
|
+
const raw = Array.isArray(value) ? value.join('/') : value;
|
|
168
|
+
return (0, path_1.safeRelPath)(raw);
|
|
169
|
+
}
|
|
170
|
+
/**
|
|
171
|
+
* 默认禁止上传的服务端脚本扩展名。
|
|
172
|
+
* 存储目录若位于静态服务的根目录下,上传的可执行脚本可能被 php-cgi 等中间件执行,
|
|
173
|
+
* 相当于对外开放了远程代码执行入口,因此在上传环节直接拦截。
|
|
174
|
+
*/
|
|
175
|
+
exports.DEFAULT_BLOCK_EXTENSIONS = [
|
|
176
|
+
'.php',
|
|
177
|
+
'.php3',
|
|
178
|
+
'.php4',
|
|
179
|
+
'.php5',
|
|
180
|
+
'.php7',
|
|
181
|
+
'.php8',
|
|
182
|
+
'.phtml',
|
|
183
|
+
'.pht',
|
|
184
|
+
'.phar',
|
|
185
|
+
'.cgi',
|
|
186
|
+
'.pl',
|
|
187
|
+
'.py',
|
|
188
|
+
'.rb',
|
|
189
|
+
'.sh',
|
|
190
|
+
'.asp',
|
|
191
|
+
'.aspx',
|
|
192
|
+
'.jsp',
|
|
193
|
+
'.jspx',
|
|
194
|
+
];
|
|
195
|
+
/** 带状态码的业务错误,便于错误处理中间件输出友好提示 */
|
|
196
|
+
class LocalsendError extends Error {
|
|
197
|
+
statusCode;
|
|
198
|
+
constructor(message, statusCode = 400) {
|
|
199
|
+
super(message);
|
|
200
|
+
this.name = 'LocalsendError';
|
|
201
|
+
this.statusCode = statusCode;
|
|
202
|
+
}
|
|
203
|
+
}
|
|
204
|
+
/**
|
|
205
|
+
* 计算目录占用(字节,递归子目录)。忽略读取失败的条目。
|
|
206
|
+
*
|
|
207
|
+
* 内部目录(分片暂存、回收站)不计入:前者是临时数据,
|
|
208
|
+
* 后者由回收站单独统计,混在一起会让「已用空间」与文件列表对不上。
|
|
209
|
+
*/
|
|
210
|
+
function dirSize(target, skipInternal = true) {
|
|
211
|
+
if (!(0, node_fs_1.existsSync)(target))
|
|
212
|
+
return 0;
|
|
213
|
+
let total = 0;
|
|
214
|
+
const walk = (current) => {
|
|
215
|
+
let names;
|
|
216
|
+
try {
|
|
217
|
+
names = (0, node_fs_1.readdirSync)(current);
|
|
218
|
+
}
|
|
219
|
+
catch {
|
|
220
|
+
return;
|
|
221
|
+
}
|
|
222
|
+
for (const name of names) {
|
|
223
|
+
if (skipInternal && (0, path_1.isInternalDirName)(name))
|
|
224
|
+
continue;
|
|
225
|
+
const full = (0, node_path_1.join)(current, name);
|
|
226
|
+
try {
|
|
227
|
+
const stat = (0, node_fs_1.statSync)(full);
|
|
228
|
+
if (stat.isDirectory())
|
|
229
|
+
walk(full);
|
|
230
|
+
else if (stat.isFile())
|
|
231
|
+
total += stat.size;
|
|
232
|
+
}
|
|
233
|
+
catch {
|
|
234
|
+
// 文件可能刚好被删除,跳过
|
|
235
|
+
}
|
|
236
|
+
}
|
|
237
|
+
};
|
|
238
|
+
walk(target);
|
|
239
|
+
return total;
|
|
240
|
+
}
|
|
241
|
+
async function initLocalsend(app) {
|
|
242
|
+
const config = await (0, config_1.getConfig)();
|
|
243
|
+
const raw = config.localsend;
|
|
244
|
+
if (!raw)
|
|
245
|
+
return { stop: () => { } };
|
|
246
|
+
const ls = typeof raw === 'boolean' ? { enabled: raw } : raw;
|
|
247
|
+
if (!ls.enabled)
|
|
248
|
+
return { stop: () => { } };
|
|
249
|
+
const dir = ls.dir || '';
|
|
250
|
+
if (!(0, node_fs_1.existsSync)(dir))
|
|
251
|
+
(0, node_fs_1.mkdirSync)(dir, { recursive: true });
|
|
252
|
+
// ---------------------------------------------------------------------------
|
|
253
|
+
// 运行时设置
|
|
254
|
+
//
|
|
255
|
+
// 配置文件的值是「出厂设置」,管理员在网页端改过的值单独存一份,
|
|
256
|
+
// 启动时合并进来并立即生效,无需重启服务。
|
|
257
|
+
// ---------------------------------------------------------------------------
|
|
258
|
+
const settings = (0, settings_1.createSettingsStore)();
|
|
259
|
+
settings.load();
|
|
260
|
+
const merged = settings.apply(ls);
|
|
261
|
+
/** 当前生效的配置,管理员修改后直接改这里,各处读取时随之更新 */
|
|
262
|
+
const live = {
|
|
263
|
+
token: String(merged.token || ''),
|
|
264
|
+
password: String(merged.password || ''),
|
|
265
|
+
visitorPassword: String(merged.visitorPassword || ''),
|
|
266
|
+
sessionTtl: Number(merged.sessionTtl) || 24 * 60 * 60 * 1000,
|
|
267
|
+
// 未设置时默认 1GB;显式设为 0 表示不限制
|
|
268
|
+
maxSize: merged.maxSize === undefined ? 1024 * 1024 * 1024 : Number(merged.maxSize),
|
|
269
|
+
maxTotalSize: Number(merged.maxTotalSize) || 0,
|
|
270
|
+
maxConcurrent: Number(merged.maxConcurrent ?? 3),
|
|
271
|
+
rateLimit: {
|
|
272
|
+
windowMs: Number(merged.rateLimit?.windowMs) || 60_000,
|
|
273
|
+
max: Number(merged.rateLimit?.max ?? 120),
|
|
274
|
+
},
|
|
275
|
+
blockExtensions: [...(merged.blockExtensions || exports.DEFAULT_BLOCK_EXTENSIONS)],
|
|
276
|
+
trashDays: Number(merged.trashDays ?? 1),
|
|
277
|
+
autoCleanDays: Number(merged.autoCleanDays) || 0,
|
|
278
|
+
autoCleanMaxSize: Number(merged.autoCleanMaxSize) || 0,
|
|
279
|
+
};
|
|
280
|
+
/** 当前禁止上传/保存的扩展名集合(含点、小写),运行时修改立即生效 */
|
|
281
|
+
const getBlockExts = () => new Set(live.blockExtensions.map((e) => (e.startsWith('.') ? e : `.${e}`).toLowerCase()));
|
|
282
|
+
// ---------------------------------------------------------------------------
|
|
283
|
+
// 审计与指标
|
|
284
|
+
//
|
|
285
|
+
// 审计只记「改了东西」的操作(删除、整理、分享、设置、认证),
|
|
286
|
+
// 日志写在用户配置目录而不是存储目录:不会被文件列表、配额、
|
|
287
|
+
// 自动清理、WebDAV 看到,也不会被「清空回收站」带走。
|
|
288
|
+
// ---------------------------------------------------------------------------
|
|
289
|
+
const audit = (0, audit_1.createAuditLog)({
|
|
290
|
+
file: process.env.SS_LOCALSEND_AUDIT || (0, node_path_1.join)((0, config_1.getUserConfigDir)(), 'localsend-audit.log'),
|
|
291
|
+
});
|
|
292
|
+
const metrics = (0, metrics_1.createMetrics)();
|
|
293
|
+
/**
|
|
294
|
+
* 记一条审计。
|
|
295
|
+
*
|
|
296
|
+
* 只记角色与动作,绝不记口令、令牌、会话;
|
|
297
|
+
* roleOverride 用于认证接口(此时身份中间件还没跑)。
|
|
298
|
+
*/
|
|
299
|
+
function auditAction(req, res, action, target, extra, roleOverride) {
|
|
300
|
+
const role = roleOverride || (res && res.locals?.role) || 'guest';
|
|
301
|
+
metrics.inc(`action.${action}`);
|
|
302
|
+
audit.record({
|
|
303
|
+
ip: (0, guard_1.clientIp)(req),
|
|
304
|
+
role: String(role),
|
|
305
|
+
action,
|
|
306
|
+
target,
|
|
307
|
+
extra,
|
|
308
|
+
});
|
|
309
|
+
}
|
|
310
|
+
// 回收站:删除的文件先移入此处,可在一段时间内还原
|
|
311
|
+
const trash = (0, trash_1.createTrash)({
|
|
312
|
+
dir,
|
|
313
|
+
ttl: () => live.trashDays * 24 * 60 * 60 * 1000,
|
|
314
|
+
});
|
|
315
|
+
// 自动清理:避免接收端长期运行把磁盘撑满
|
|
316
|
+
// 始终创建,以便管理员在网页端随时开启或调整清理策略
|
|
317
|
+
const cleaner = (0, cleaner_1.createCleaner)({
|
|
318
|
+
dir,
|
|
319
|
+
maxAgeDays: () => live.autoCleanDays,
|
|
320
|
+
maxTotalSize: () => live.autoCleanMaxSize,
|
|
321
|
+
onRemoved: (names) => get_logger_1.logger.log(console_log_colors_1.color.yellow('LocalSend 清理 : '.padStart(15, ' ')), console_log_colors_1.color.yellowBright(`已删除 ${names.length} 个过期文件`)),
|
|
322
|
+
});
|
|
323
|
+
// 启动时先清理一次
|
|
324
|
+
setTimeout(() => cleaner.run(), 5000).unref?.();
|
|
325
|
+
const port = config.port || 80;
|
|
326
|
+
/**
|
|
327
|
+
* 启动时列出全部候选地址。
|
|
328
|
+
*
|
|
329
|
+
* 以前只打印一个地址,且取到的是「排序后的第一个」——多网卡机器
|
|
330
|
+
* (WSL / Docker / VPN / 虚拟机)经常拿到一个手机根本连不上的地址,
|
|
331
|
+
* 用户扫码后只会看到「无法访问此网站」,却不知道是网卡选错了。
|
|
332
|
+
*/
|
|
333
|
+
const ipCandidates = (0, utils_1.getIpCandidates)();
|
|
334
|
+
const ipUrl = `http://${ipCandidates[0]?.address || 'localhost'}:${port}`;
|
|
335
|
+
get_logger_1.logger.log(console_log_colors_1.color.green('LocalSend : '.padStart(15, ' ')), console_log_colors_1.color.greenBright('局域网文件传输功能已开启'));
|
|
336
|
+
get_logger_1.logger.log(console_log_colors_1.color.green('LocalSend DIR : '.padStart(15, ' ')), console_log_colors_1.color.cyanBright(dir));
|
|
337
|
+
get_logger_1.logger.log(console_log_colors_1.color.green('LocalSend URL : '.padStart(15, ' ')), console_log_colors_1.color.cyanBright(`${ipUrl}/localsend`));
|
|
338
|
+
if (ipCandidates.length > 1) {
|
|
339
|
+
const others = ipCandidates
|
|
340
|
+
.slice(1)
|
|
341
|
+
.map((item) => `${item.address}(${item.iface})`)
|
|
342
|
+
.join(' ');
|
|
343
|
+
get_logger_1.logger.log(console_log_colors_1.color.green('LocalSend 其它地址 :'.padStart(15, ' ')), console_log_colors_1.color.gray(`${others}(页面可切换后重新生成二维码)`));
|
|
344
|
+
}
|
|
345
|
+
if (live.token)
|
|
346
|
+
get_logger_1.logger.log(console_log_colors_1.color.green('LocalSend KEY : '.padStart(15, ' ')), console_log_colors_1.color.yellowBright('已启用访问令牌(访问时需输入令牌换取会话)'));
|
|
347
|
+
// 分享链接:拿到链接的人无需访问令牌即可下载指定文件(需在令牌校验之前注册)
|
|
348
|
+
const shareStore = (0, share_1.createShareStore)();
|
|
349
|
+
app.get('/localsend/s/:token', async (req, res) => {
|
|
350
|
+
const entry = shareStore.get(String(req.params.token || ''));
|
|
351
|
+
if (!entry)
|
|
352
|
+
return void res.status(404).json({ code: 1, msg: '分享链接不存在或已过期' });
|
|
353
|
+
const files = entry.names
|
|
354
|
+
.map((rel) => ({ rel, path: (0, path_1.resolveInDir)(dir, rel) }))
|
|
355
|
+
.filter((f) => f.path && (0, node_fs_1.existsSync)(f.path) && (0, node_fs_1.statSync)(f.path).isFile());
|
|
356
|
+
if (!files.length)
|
|
357
|
+
return void res.status(404).json({ code: 1, msg: '分享的文件已不存在' });
|
|
358
|
+
if (files.length === 1) {
|
|
359
|
+
const file = files[0];
|
|
360
|
+
// 文本与图片直接在浏览器里打开,扫一眼就能看到内容,不必先下载
|
|
361
|
+
// 需要强制下载时加 ?dl=1
|
|
362
|
+
const inline = req.query.dl === undefined ? (0, share_1.shareInlineType)(file.rel) : false;
|
|
363
|
+
if (inline) {
|
|
364
|
+
res.setHeader('Content-Type', (0, share_1.shareInlineMime)(file.rel));
|
|
365
|
+
res.setHeader('Content-Disposition', `inline; filename*=UTF-8''${encodeURIComponent((0, node_path_1.basename)(file.rel))}`);
|
|
366
|
+
(0, node_fs_1.createReadStream)(file.path).pipe(res);
|
|
367
|
+
return;
|
|
368
|
+
}
|
|
369
|
+
res.download(file.path, (0, node_path_1.basename)(file.rel), { dotfiles: 'allow' });
|
|
370
|
+
return;
|
|
371
|
+
}
|
|
372
|
+
const stamp = new Date().toISOString().slice(0, 16).replace(/[-:T]/g, '');
|
|
373
|
+
res.setHeader('Content-Type', 'application/zip');
|
|
374
|
+
res.setHeader('Content-Disposition', `attachment; filename="localsend-${stamp}.zip"`);
|
|
375
|
+
try {
|
|
376
|
+
for await (const chunk of (0, zip_1.createZipChunks)(files.map((f) => ({ name: f.rel, path: f.path, mtime: (0, node_fs_1.statSync)(f.path).mtime })), (p) => (0, node_fs_1.createReadStream)(p))) {
|
|
377
|
+
res.write(chunk);
|
|
378
|
+
}
|
|
379
|
+
res.end();
|
|
380
|
+
}
|
|
381
|
+
catch (err) {
|
|
382
|
+
get_logger_1.logger.error('[localsend share]', err);
|
|
383
|
+
res.end();
|
|
384
|
+
}
|
|
385
|
+
});
|
|
386
|
+
// ---------------------------------------------------------------------------
|
|
387
|
+
// 短期访问票据
|
|
388
|
+
//
|
|
389
|
+
// 下载、预览、打包、事件流这几类 URL 由 <img> / <video> / <a download> /
|
|
390
|
+
// EventSource 直接发起,没法带自定义请求头,也不能把会话令牌拼进 URL
|
|
391
|
+
// (复制链接、浏览器历史、网关日志都会把会话带出去)。
|
|
392
|
+
// 因此先换一张短期票据,再用票据访问;票据只对指定文件有效,几分钟后失效。
|
|
393
|
+
// ---------------------------------------------------------------------------
|
|
394
|
+
const ticketStore = (0, ticket_1.createTicketStore)();
|
|
395
|
+
/** 发送下载响应 */
|
|
396
|
+
function sendDownloadResponse(res, rel) {
|
|
397
|
+
const filePath = (0, path_1.resolveInDir)(dir, rel);
|
|
398
|
+
if (!filePath || !(0, node_fs_1.existsSync)(filePath) || !(0, node_fs_1.statSync)(filePath).isFile()) {
|
|
399
|
+
res.status(404).json({ code: 1, msg: '文件不存在' });
|
|
400
|
+
return;
|
|
401
|
+
}
|
|
402
|
+
res.download(filePath, (0, node_path_1.basename)(rel), { dotfiles: 'allow' });
|
|
403
|
+
}
|
|
404
|
+
/** 发送预览响应(inline,浏览器可直读图片/文本/音视频) */
|
|
405
|
+
function sendPreviewResponse(res, rel) {
|
|
406
|
+
const filePath = (0, path_1.resolveInDir)(dir, rel);
|
|
407
|
+
if (!filePath || !(0, node_fs_1.existsSync)(filePath) || !(0, node_fs_1.statSync)(filePath).isFile()) {
|
|
408
|
+
res.status(404).json({ code: 1, msg: '文件不存在' });
|
|
409
|
+
return;
|
|
410
|
+
}
|
|
411
|
+
res.sendFile(filePath, {
|
|
412
|
+
dotfiles: 'allow',
|
|
413
|
+
headers: { 'Content-Disposition': `inline; filename*=UTF-8''${encodeURIComponent((0, node_path_1.basename)(rel))}` },
|
|
414
|
+
});
|
|
415
|
+
}
|
|
416
|
+
/** 把多个文件流式打成 zip 输出 */
|
|
417
|
+
async function sendZipResponse(res, names) {
|
|
418
|
+
const entries = [];
|
|
419
|
+
for (const rel of names.slice(0, 500)) {
|
|
420
|
+
const filePath = (0, path_1.resolveInDir)(dir, rel);
|
|
421
|
+
if (!filePath || !(0, node_fs_1.existsSync)(filePath) || !(0, node_fs_1.statSync)(filePath).isFile())
|
|
422
|
+
continue;
|
|
423
|
+
entries.push({ name: rel, path: filePath, mtime: (0, node_fs_1.statSync)(filePath).mtime });
|
|
424
|
+
}
|
|
425
|
+
if (!entries.length) {
|
|
426
|
+
res.status(404).json({ code: 1, msg: '没有可打包的文件' });
|
|
427
|
+
return;
|
|
428
|
+
}
|
|
429
|
+
const stamp = new Date().toISOString().slice(0, 16).replace(/[-:T]/g, '');
|
|
430
|
+
res.setHeader('Content-Type', 'application/zip');
|
|
431
|
+
res.setHeader('Content-Disposition', `attachment; filename="localsend-${stamp}.zip"; filename*=UTF-8''localsend-${stamp}.zip`);
|
|
432
|
+
try {
|
|
433
|
+
for await (const chunk of (0, zip_1.createZipChunks)(entries, (p) => (0, node_fs_1.createReadStream)(p))) {
|
|
434
|
+
res.write(chunk);
|
|
435
|
+
}
|
|
436
|
+
res.end();
|
|
437
|
+
}
|
|
438
|
+
catch (err) {
|
|
439
|
+
get_logger_1.logger.error('[localsend zip]', err);
|
|
440
|
+
res.end();
|
|
441
|
+
}
|
|
442
|
+
}
|
|
443
|
+
/** 建立 SSE 事件流 */
|
|
444
|
+
function openEventStream(req, res) {
|
|
445
|
+
res.set({
|
|
446
|
+
'Content-Type': 'text/event-stream; charset=utf-8',
|
|
447
|
+
'Cache-Control': 'no-cache, no-transform',
|
|
448
|
+
Connection: 'keep-alive',
|
|
449
|
+
'X-Accel-Buffering': 'no',
|
|
450
|
+
});
|
|
451
|
+
res.flushHeaders?.();
|
|
452
|
+
// 建议客户端 3 秒重连,并先发一个 ready 事件确认连接建立
|
|
453
|
+
res.write('retry: 3000\n\n');
|
|
454
|
+
res.write('event: ready\ndata: {}\n\n');
|
|
455
|
+
eventClients.add(res);
|
|
456
|
+
req.on('close', () => {
|
|
457
|
+
eventClients.delete(res);
|
|
458
|
+
});
|
|
459
|
+
}
|
|
460
|
+
/** 票据失效:前端据此重新换票后重试 */
|
|
461
|
+
function rejectTicket(res) {
|
|
462
|
+
res.status(401).json({ code: 1, msg: '访问链接已过期,请重试', ticketExpired: true });
|
|
463
|
+
}
|
|
464
|
+
/** 校验票据并取出要访问的文件;不允许时直接写响应并返回空串 */
|
|
465
|
+
function relOfTicket(req, res, scope) {
|
|
466
|
+
const entry = ticketStore.get(String(req.params.token || ''), scope);
|
|
467
|
+
if (!entry) {
|
|
468
|
+
rejectTicket(res);
|
|
469
|
+
return '';
|
|
470
|
+
}
|
|
471
|
+
const rel = relParam(req);
|
|
472
|
+
if (!rel) {
|
|
473
|
+
res.status(400).json({ code: 1, msg: '非法的文件路径' });
|
|
474
|
+
return '';
|
|
475
|
+
}
|
|
476
|
+
if (!ticketStore.allows(entry, rel)) {
|
|
477
|
+
res.status(403).json({ code: 1, msg: '票据不适用于该文件' });
|
|
478
|
+
return '';
|
|
479
|
+
}
|
|
480
|
+
return rel;
|
|
481
|
+
}
|
|
482
|
+
// 票据路由必须注册在访问令牌校验之前:这些 URL 带不了请求头。
|
|
483
|
+
// 同时也位于接口限流之前——视频拖动进度条会连续发起多个 Range 请求,
|
|
484
|
+
// 用「接口调用」的预算去卡它会直接毁掉播放体验;票据本身不可猜且几分钟即失效,
|
|
485
|
+
// 因此这里以票据作为准入凭证,不再叠加接口频率限制。
|
|
486
|
+
app.get('/localsend/api/t/:token/download/*name', (req, res) => {
|
|
487
|
+
const rel = relOfTicket(req, res, 'download');
|
|
488
|
+
if (rel)
|
|
489
|
+
sendDownloadResponse(res, rel);
|
|
490
|
+
});
|
|
491
|
+
app.get('/localsend/api/t/:token/preview/*name', (req, res) => {
|
|
492
|
+
const rel = relOfTicket(req, res, 'preview');
|
|
493
|
+
if (rel)
|
|
494
|
+
sendPreviewResponse(res, rel);
|
|
495
|
+
});
|
|
496
|
+
app.get('/localsend/api/t/:token/zip', (req, res) => {
|
|
497
|
+
const entry = ticketStore.get(String(req.params.token || ''), 'zip');
|
|
498
|
+
if (!entry)
|
|
499
|
+
return void rejectTicket(res);
|
|
500
|
+
const names = String(req.query.names || '')
|
|
501
|
+
.split(',')
|
|
502
|
+
.map((n) => (0, path_1.safeRelPath)(n))
|
|
503
|
+
.filter(Boolean);
|
|
504
|
+
if (!names.length)
|
|
505
|
+
return void res.status(400).json({ code: 1, msg: '未指定要打包的文件' });
|
|
506
|
+
// 票据只覆盖签发时列出的文件,避免被拿去打包任意路径
|
|
507
|
+
const allowed = names.every((rel) => ticketStore.allows(entry, rel));
|
|
508
|
+
if (!allowed)
|
|
509
|
+
return void res.status(403).json({ code: 1, msg: '票据不适用于这些文件' });
|
|
510
|
+
void sendZipResponse(res, names);
|
|
511
|
+
});
|
|
512
|
+
app.get('/localsend/api/t/:token/events', (req, res) => {
|
|
513
|
+
const entry = ticketStore.get(String(req.params.token || ''), 'events');
|
|
514
|
+
if (!entry)
|
|
515
|
+
return void rejectTicket(res);
|
|
516
|
+
openEventStream(req, res);
|
|
517
|
+
});
|
|
518
|
+
// ---------------------------------------------------------------------------
|
|
519
|
+
// 访问控制
|
|
520
|
+
//
|
|
521
|
+
// 注册顺序很关键:
|
|
522
|
+
// 1. 身份与摘要库要先建好:WebDAV 与令牌校验都要用到它
|
|
523
|
+
// 2. 分享下载页与 WebDAV 必须放在令牌校验之前
|
|
524
|
+
// —— 分享链接本就是免登录的,WebDAV 走 Basic Auth 带不了自定义请求头
|
|
525
|
+
// 3. 认证接口(取盐值、口令登录、令牌换会话)也要放在令牌校验之前,
|
|
526
|
+
// 否则用户还没拿到会话就无从登录
|
|
527
|
+
// 4. 令牌校验之后才是全部业务接口,任何接口都不能绕过
|
|
528
|
+
// 5. 身份分级再叠在令牌之上,用来区分危险操作的权限
|
|
529
|
+
// ---------------------------------------------------------------------------
|
|
530
|
+
// 身份与权限
|
|
531
|
+
//
|
|
532
|
+
// token 是站点级大门锁,这里是进门后的身份分级:
|
|
533
|
+
// 管理员能删除与整理,访客只能上传下载。
|
|
534
|
+
// 没有配置访客口令时,未登录的人也能上传下载(删除与整理仍需管理员口令)。
|
|
535
|
+
// 没有配置任何口令时保持开放模式,行为与以前完全一致。
|
|
536
|
+
const auth = (0, auth_1.createAuth)({
|
|
537
|
+
password: live.password,
|
|
538
|
+
visitorPassword: live.visitorPassword,
|
|
539
|
+
token: live.token,
|
|
540
|
+
sessionTtl: live.sessionTtl,
|
|
541
|
+
});
|
|
542
|
+
if (auth.open) {
|
|
543
|
+
get_logger_1.logger.log(console_log_colors_1.color.yellow('LocalSend 权限 :'.padStart(15, ' ')), console_log_colors_1.color.yellow('未设置口令,任何人都可以删除与整理文件'));
|
|
544
|
+
}
|
|
545
|
+
else if (live.visitorPassword) {
|
|
546
|
+
get_logger_1.logger.log(console_log_colors_1.color.green('LocalSend 权限 :'.padStart(15, ' ')), console_log_colors_1.color.cyanBright('已启用身份分级(危险操作需要管理员口令,上传下载需要访客口令)'));
|
|
547
|
+
}
|
|
548
|
+
else {
|
|
549
|
+
get_logger_1.logger.log(console_log_colors_1.color.green('LocalSend 权限 :'.padStart(15, ' ')), console_log_colors_1.color.cyanBright('已启用身份分级(危险操作需要管理员口令,上传下载无需口令)'));
|
|
550
|
+
}
|
|
551
|
+
if (live.visitorPassword && !auth.hasAdmin) {
|
|
552
|
+
get_logger_1.logger.log(console_log_colors_1.color.yellow('LocalSend 权限 :'.padStart(15, ' ')), console_log_colors_1.color.yellow('只配置了访客口令,删除与整理将无法执行'));
|
|
553
|
+
}
|
|
554
|
+
/** 从请求中取会话令牌 */
|
|
555
|
+
function sessionTokenOf(req) {
|
|
556
|
+
return String(req.get('X-Localsend-Session') || req.query.session || '');
|
|
557
|
+
}
|
|
558
|
+
// 访问防护:令牌 / 频率限制 / 并发限制
|
|
559
|
+
const guard = (0, guard_1.createGuard)({
|
|
560
|
+
hasToken: () => auth.hasToken,
|
|
561
|
+
// 请求头里的令牌摘要:脚本等非浏览器客户端可以直接用
|
|
562
|
+
verifyKey: (digest) => auth.verifyToken(digest),
|
|
563
|
+
verifySession: (token) => !!auth.get(token),
|
|
564
|
+
maxConcurrent: () => live.maxConcurrent,
|
|
565
|
+
rateLimit: () => live.rateLimit,
|
|
566
|
+
/**
|
|
567
|
+
* 分片上传的独立预算。
|
|
568
|
+
*
|
|
569
|
+
* 分片按「片」发请求:1GB / 4MB 就是 256 个请求,必然打满 120 次/分的
|
|
570
|
+
* 普通接口预算,表现为「大文件传到一半就失败」。这里按「一次完整上传
|
|
571
|
+
* 所需的分片数 × 2 + 余量」给预算,既允许传完,也仍然拦得住滥用。
|
|
572
|
+
*/
|
|
573
|
+
chunkRateLimit: () => {
|
|
574
|
+
const chunkSize = 4 * 1024 * 1024; // 与网页端的分片大小一致
|
|
575
|
+
const maxSize = live.maxSize > 0 ? live.maxSize : 1024 * 1024 * 1024;
|
|
576
|
+
const chunks = Math.ceil(maxSize / chunkSize);
|
|
577
|
+
return { windowMs: live.rateLimit.windowMs, max: Math.max(300, chunks * 2 + 50) };
|
|
578
|
+
},
|
|
579
|
+
// 被限流的次数是判断「是不是有人刷接口」和「限流是不是配太紧」的关键指标
|
|
580
|
+
onRateLimited: () => metrics.inc('http.429'),
|
|
581
|
+
});
|
|
582
|
+
// WebDAV 挂载接口:把存储目录暴露为网络盘(资源管理器 / iOS 文件 App 均可挂载)。
|
|
583
|
+
if (ls.webdav !== false) {
|
|
584
|
+
const davHandler = (0, webdav_1.createWebDavHandler)({
|
|
585
|
+
dir,
|
|
586
|
+
hasToken: () => auth.hasToken,
|
|
587
|
+
// WebDAV 客户端只能用 Basic Auth 传明文,服务端用盐值现场算摘要再比对
|
|
588
|
+
verifyToken: (presented) => auth.verifyTokenValue(presented),
|
|
589
|
+
verifyPlain: (value) => auth.plainRole(value),
|
|
590
|
+
isOpen: () => auth.open,
|
|
591
|
+
hasVisitor: () => auth.hasVisitor,
|
|
592
|
+
maxSize: () => live.maxSize,
|
|
593
|
+
maxTotalSize: () => live.maxTotalSize,
|
|
594
|
+
blockExtensions: () => live.blockExtensions,
|
|
595
|
+
basePath: '/localsend/dav',
|
|
596
|
+
// WebDAV 侧的删除/上传/移动同样进审计:资源管理器里删文件也是真删
|
|
597
|
+
onWrite: (action, target, req, role) => auditAction(req, null, action, target, undefined, role),
|
|
598
|
+
});
|
|
599
|
+
app.use('/localsend/dav', davHandler);
|
|
600
|
+
get_logger_1.logger.log(console_log_colors_1.color.green('LocalSend DAV : '.padStart(15, ' ')), console_log_colors_1.color.cyanBright(`${ipUrl}/localsend/dav`));
|
|
601
|
+
}
|
|
602
|
+
/**
|
|
603
|
+
* HTTP 下的能力降级提示。
|
|
604
|
+
*
|
|
605
|
+
* 手机通过局域网 IP 以 http 访问时属于「非安全上下文」,浏览器会禁用
|
|
606
|
+
* Service Worker(PWA 安装)、剪贴板读写、目录监听、系统分享与通知等能力。
|
|
607
|
+
* 这不是缺陷但很容易被当成缺陷,因此在启动时就说明,并给出解锁方式。
|
|
608
|
+
*/
|
|
609
|
+
if (!config.https) {
|
|
610
|
+
get_logger_1.logger.log(console_log_colors_1.color.yellow('LocalSend 提示 :'.padStart(15, ' ')), console_log_colors_1.color.yellow('当前为 HTTP 访问:手机端的安装到桌面、剪贴板、目录监听等功能不可用;需要时可用 --https 启动并信任自签证书'));
|
|
611
|
+
}
|
|
612
|
+
// ---------------------------------------------------------------------------
|
|
613
|
+
// 接口频率限制
|
|
614
|
+
//
|
|
615
|
+
// 放在认证接口之前:盐值/登录/换令牌这三个接口免鉴权,
|
|
616
|
+
// 而摘要比对本身要跑 PBKDF2,是最耗 CPU 的路径。
|
|
617
|
+
// 不限流的话,一次死循环式的重复提交就能把服务端的 CPU 打满。
|
|
618
|
+
//
|
|
619
|
+
// 分片上传走独立的桶:它按「片」发请求,一个大文件天然产生几百个请求,
|
|
620
|
+
// 与普通接口共用预算就会「越大越传不完」。鉴权与并发限制仍然照旧生效。
|
|
621
|
+
// ---------------------------------------------------------------------------
|
|
622
|
+
app.use('/localsend/api', (req, res, next) => {
|
|
623
|
+
if (req.path.startsWith('/chunk/'))
|
|
624
|
+
return guard.rateLimitChunk(req, res, next);
|
|
625
|
+
return guard.rateLimit(req, res, next);
|
|
626
|
+
});
|
|
627
|
+
// ---------------------------------------------------------------------------
|
|
628
|
+
// 认证接口(免鉴权):客户端先取盐值算出摘要,再换取会话令牌
|
|
629
|
+
// ---------------------------------------------------------------------------
|
|
630
|
+
// 各密钥的公开盐值:客户端据此派生出摘要,明文口令与原始令牌都不出浏览器
|
|
631
|
+
app.get('/localsend/api/auth/salt', (_req, res) => {
|
|
632
|
+
res.json({ code: 0, data: { iterations: secret_1.SECRET_ITERATIONS, secrets: auth.secrets() } });
|
|
633
|
+
});
|
|
634
|
+
// 口令登录:提交摘要,服务端比对后签发会话。
|
|
635
|
+
// 管理员口令、访客口令、访问令牌都从这一个入口进来——
|
|
636
|
+
// 前端只显示一个输入框,用户不必先分辨自己手里拿的是哪一种。
|
|
637
|
+
app.post('/localsend/api/auth/login', express_1.default.json({ limit: '4kb' }), (req, res) => {
|
|
638
|
+
const digests = (req.body?.digests || {});
|
|
639
|
+
const session = auth.login(digests);
|
|
640
|
+
if (!session) {
|
|
641
|
+
// 不区分口令不存在还是口令错误,避免暴露配置细节;但失败次数要记下来
|
|
642
|
+
metrics.inc('auth.fail');
|
|
643
|
+
auditAction(req, res, 'auth.fail', 'login');
|
|
644
|
+
return void res.status(401).json({ code: 1, msg: '口令或访问令牌不正确' });
|
|
645
|
+
}
|
|
646
|
+
metrics.inc('auth.ok');
|
|
647
|
+
auditAction(req, res, 'auth.login', session.via, undefined, session.role);
|
|
648
|
+
res.json({ code: 0, data: { token: session.token, role: session.role, via: session.via, expiresAt: session.expiresAt } });
|
|
649
|
+
});
|
|
650
|
+
// 访问令牌换会话:令牌只在这一步参与,之后请求里只有会话令牌
|
|
651
|
+
app.post('/localsend/api/auth/token', express_1.default.json({ limit: '4kb' }), (req, res) => {
|
|
652
|
+
const session = auth.loginByToken(String(req.body?.digest || ''));
|
|
653
|
+
if (!session) {
|
|
654
|
+
metrics.inc('auth.fail');
|
|
655
|
+
auditAction(req, res, 'auth.fail', 'token');
|
|
656
|
+
return void res.status(401).json({ code: 1, msg: '访问令牌不正确' });
|
|
657
|
+
}
|
|
658
|
+
metrics.inc('auth.ok');
|
|
659
|
+
auditAction(req, res, 'auth.login', 'token', undefined, session.role);
|
|
660
|
+
res.json({ code: 0, data: { token: session.token, role: session.role, expiresAt: session.expiresAt } });
|
|
661
|
+
});
|
|
662
|
+
/**
|
|
663
|
+
* 候选访问地址(免鉴权)。
|
|
664
|
+
*
|
|
665
|
+
* 页面用这些地址生成二维码。手机扫码打不开的第一大原因,是主机有多张网卡
|
|
666
|
+
* (WSL / Docker / VPN / 虚拟机)而服务端取错了那一个——这里把全部候选
|
|
667
|
+
* 连同「本次请求实际连上的地址」一起返回,由页面决定展示与切换。
|
|
668
|
+
*
|
|
669
|
+
* 不含任何用户数据,因此放在令牌校验之前:页面还没输入访问令牌时
|
|
670
|
+
* 也要能把二维码画出来。
|
|
671
|
+
*/
|
|
672
|
+
app.get('/localsend/api/network', (req, res) => {
|
|
673
|
+
// 客户端实际连上的本机地址,对它一定可达
|
|
674
|
+
const connected = String(req.socket?.localAddress || '');
|
|
675
|
+
const addresses = (0, utils_1.getIpCandidates)();
|
|
676
|
+
let suggested = '';
|
|
677
|
+
if (connected && !(0, utils_1.isLoopbackAddress)(connected) && (0, utils_1.isPrivateAddress)(connected)) {
|
|
678
|
+
suggested = connected;
|
|
679
|
+
}
|
|
680
|
+
if (!suggested)
|
|
681
|
+
suggested = addresses[0]?.address || '';
|
|
682
|
+
res.json({
|
|
683
|
+
code: 0,
|
|
684
|
+
data: {
|
|
685
|
+
addresses,
|
|
686
|
+
suggested,
|
|
687
|
+
connected,
|
|
688
|
+
loopback: !connected || (0, utils_1.isLoopbackAddress)(connected),
|
|
689
|
+
},
|
|
690
|
+
});
|
|
691
|
+
});
|
|
692
|
+
// 访问令牌校验(配置了 token 才生效):页面与静态资源放行,接口需要会话或令牌摘要
|
|
693
|
+
app.use('/localsend', guard.requireAuth);
|
|
694
|
+
// 身份中间件:把当前角色挂到 res.locals.role
|
|
695
|
+
app.use('/localsend/api', (req, res, next) => {
|
|
696
|
+
res.locals.role = auth.roleOf(sessionTokenOf(req));
|
|
697
|
+
next();
|
|
698
|
+
});
|
|
699
|
+
/** 需要管理员权限:删除、整理、撤销分享、清理回收站等危险操作 */
|
|
700
|
+
function requireAdmin(_req, res, next) {
|
|
701
|
+
if ((0, auth_1.canManage)(res.locals.role))
|
|
702
|
+
return next();
|
|
703
|
+
// needAuth 供前端识别「需要登录」而不是其它 403(如禁止上传的类型)
|
|
704
|
+
res.status(403).json({ code: 1, msg: '该操作需要管理员权限,请先登录', needAuth: true });
|
|
705
|
+
}
|
|
706
|
+
/** 需要写入权限:上传、粘贴、创建分享等 */
|
|
707
|
+
function requireWrite(_req, res, next) {
|
|
708
|
+
// 未配置访客口令时,任何人都能上传下载;配置了则必须先登录
|
|
709
|
+
if ((0, auth_1.canWrite)(res.locals.role, !!live.visitorPassword))
|
|
710
|
+
return next();
|
|
711
|
+
res.status(403).json({ code: 1, msg: '上传需要访客口令,请先登录', needAuth: true });
|
|
712
|
+
}
|
|
713
|
+
/**
|
|
714
|
+
* 设置写入的权限。
|
|
715
|
+
*
|
|
716
|
+
* 开放模式(一个口令都没配)下 requireAdmin 对所有人放行,
|
|
717
|
+
* 于是局域网内任何人都能改口令/令牌、把服务接管过去:
|
|
718
|
+
* 他设置一个管理员口令后自己登录,就能删掉全部文件。
|
|
719
|
+
*
|
|
720
|
+
* 这里额外加一道限制:开放模式下只允许从本机(回环地址)发起写入。
|
|
721
|
+
* 想远程管理就先在配置文件里设置 password,或在本机浏览器里先设好口令。
|
|
722
|
+
*/
|
|
723
|
+
function requireSettingsWrite(req, res, next) {
|
|
724
|
+
if (!(0, auth_1.canManage)(res.locals.role)) {
|
|
725
|
+
return void res.status(403).json({ code: 1, msg: '该操作需要管理员权限,请先登录', needAuth: true });
|
|
726
|
+
}
|
|
727
|
+
if (auth.open) {
|
|
728
|
+
const remote = String(req.socket?.remoteAddress || '');
|
|
729
|
+
if (!(0, utils_1.isLoopbackAddress)(remote)) {
|
|
730
|
+
return void res.status(403).json({
|
|
731
|
+
code: 1,
|
|
732
|
+
msg: '尚未设置口令:只能在运行服务的本机上修改设置(也可在配置文件里设置 password 后再远程管理)',
|
|
733
|
+
needLocal: true,
|
|
734
|
+
});
|
|
735
|
+
}
|
|
736
|
+
}
|
|
737
|
+
next();
|
|
738
|
+
}
|
|
739
|
+
// 注销 / 查询当前身份
|
|
740
|
+
app.post('/localsend/api/logout', (req, res) => {
|
|
741
|
+
const token = sessionTokenOf(req);
|
|
742
|
+
auth.logout(token);
|
|
743
|
+
res.json({ code: 0, data: { role: auth.roleOf('') } });
|
|
744
|
+
});
|
|
745
|
+
app.get('/localsend/api/session', (req, res) => {
|
|
746
|
+
const session = auth.get(sessionTokenOf(req));
|
|
747
|
+
res.json({
|
|
748
|
+
code: 0,
|
|
749
|
+
data: {
|
|
750
|
+
role: res.locals.role,
|
|
751
|
+
open: auth.open,
|
|
752
|
+
hasAdmin: auth.hasAdmin,
|
|
753
|
+
hasVisitor: !!live.visitorPassword,
|
|
754
|
+
// 是否配置了访问令牌:前端据此决定要不要提示输入令牌
|
|
755
|
+
hasToken: auth.hasToken,
|
|
756
|
+
// 当前请求带的会话是否有效。
|
|
757
|
+
// 不能靠角色推断:用访问令牌换来的会话角色也是 guest,
|
|
758
|
+
// 靠角色判断会把刚换到的会话误当成失效会话清掉。
|
|
759
|
+
sessionValid: !!session,
|
|
760
|
+
expiresAt: session?.expiresAt ?? 0,
|
|
761
|
+
},
|
|
762
|
+
});
|
|
763
|
+
});
|
|
764
|
+
// ---------------------------------------------------------------------------
|
|
765
|
+
// 设置管理
|
|
766
|
+
//
|
|
767
|
+
// 管理员在网页端即可修改口令、令牌与各项限制,改完立即生效,无需重启服务。
|
|
768
|
+
// 配置文件的值是「出厂设置」,运行时改动单独存一份,
|
|
769
|
+
// 若之后用户又改了配置文件里的同一项,则以配置文件为准。
|
|
770
|
+
// ---------------------------------------------------------------------------
|
|
771
|
+
/** 敏感值脱敏:只露出开头几位,避免接口泄露完整口令 */
|
|
772
|
+
function maskValue(text) {
|
|
773
|
+
if (!text)
|
|
774
|
+
return '';
|
|
775
|
+
if (text.length <= 4)
|
|
776
|
+
return '****';
|
|
777
|
+
return `${text.slice(0, 4)}****`;
|
|
778
|
+
}
|
|
779
|
+
/**
|
|
780
|
+
* 从配置文件里的原始值算出最终生效的值(含默认值归一化)。
|
|
781
|
+
* 恢复默认设置时回到这里,而不是直接用未归一化的原始值。
|
|
782
|
+
*/
|
|
783
|
+
function configValueOf(key) {
|
|
784
|
+
const raw = ls[key];
|
|
785
|
+
switch (key) {
|
|
786
|
+
case 'token':
|
|
787
|
+
return String(raw || '');
|
|
788
|
+
case 'password':
|
|
789
|
+
return String(raw || '');
|
|
790
|
+
case 'visitorPassword':
|
|
791
|
+
return String(raw || '');
|
|
792
|
+
case 'sessionTtl':
|
|
793
|
+
return Number(raw) || 24 * 60 * 60 * 1000;
|
|
794
|
+
case 'maxSize':
|
|
795
|
+
return raw === undefined ? 1024 * 1024 * 1024 : Number(raw);
|
|
796
|
+
case 'maxTotalSize':
|
|
797
|
+
return Number(raw) || 0;
|
|
798
|
+
case 'maxConcurrent':
|
|
799
|
+
return Number(raw ?? 3);
|
|
800
|
+
case 'rateLimit':
|
|
801
|
+
return {
|
|
802
|
+
windowMs: Number(raw?.windowMs) || 60_000,
|
|
803
|
+
max: Number(raw?.max ?? 120),
|
|
804
|
+
};
|
|
805
|
+
case 'blockExtensions':
|
|
806
|
+
return [...(raw || exports.DEFAULT_BLOCK_EXTENSIONS)];
|
|
807
|
+
case 'trashDays':
|
|
808
|
+
return Number(raw ?? 1);
|
|
809
|
+
case 'autoCleanDays':
|
|
810
|
+
return Number(raw) || 0;
|
|
811
|
+
case 'autoCleanMaxSize':
|
|
812
|
+
return Number(raw) || 0;
|
|
813
|
+
default:
|
|
814
|
+
return raw;
|
|
815
|
+
}
|
|
816
|
+
}
|
|
817
|
+
/** 组装当前生效的设置项 */
|
|
818
|
+
function buildSettingsPayload() {
|
|
819
|
+
const items = Object.keys(settings_1.SETTING_DEFS).map((key) => {
|
|
820
|
+
const def = settings_1.SETTING_DEFS[key];
|
|
821
|
+
const value = live[key];
|
|
822
|
+
const empty = value === undefined || value === null || value === '' || (Array.isArray(value) && !value.length);
|
|
823
|
+
const item = {
|
|
824
|
+
key,
|
|
825
|
+
label: def.label,
|
|
826
|
+
kind: def.kind,
|
|
827
|
+
unit: def.unit || '',
|
|
828
|
+
desc: def.desc,
|
|
829
|
+
secret: !!def.secret,
|
|
830
|
+
source: settings.source(key),
|
|
831
|
+
set: !empty,
|
|
832
|
+
};
|
|
833
|
+
if (def.secret)
|
|
834
|
+
item.masked = maskValue(String(value || ''));
|
|
835
|
+
else
|
|
836
|
+
item.value = value;
|
|
837
|
+
return item;
|
|
838
|
+
});
|
|
839
|
+
return {
|
|
840
|
+
items,
|
|
841
|
+
// 这两项与路由注册、存储路径有关,改动需要重启服务
|
|
842
|
+
restartRequired: [
|
|
843
|
+
{ key: 'dir', label: '文件存储目录', value: dir },
|
|
844
|
+
{ key: 'webdav', label: 'WebDAV 网络盘', value: ls.webdav !== false },
|
|
845
|
+
],
|
|
846
|
+
file: settings.file,
|
|
847
|
+
};
|
|
848
|
+
}
|
|
849
|
+
/** 把一项设置应用到运行时;口令类改动同时让旧会话失效(当前会话保留) */
|
|
850
|
+
function applySetting(key, value, req) {
|
|
851
|
+
switch (key) {
|
|
852
|
+
case 'token':
|
|
853
|
+
live.token = String(value || '');
|
|
854
|
+
break;
|
|
855
|
+
case 'password':
|
|
856
|
+
live.password = String(value || '');
|
|
857
|
+
break;
|
|
858
|
+
case 'visitorPassword':
|
|
859
|
+
live.visitorPassword = String(value || '');
|
|
860
|
+
break;
|
|
861
|
+
case 'sessionTtl':
|
|
862
|
+
live.sessionTtl = Number(value) || live.sessionTtl;
|
|
863
|
+
break;
|
|
864
|
+
case 'maxSize':
|
|
865
|
+
live.maxSize = Number(value) || 0;
|
|
866
|
+
break;
|
|
867
|
+
case 'maxTotalSize':
|
|
868
|
+
live.maxTotalSize = Number(value) || 0;
|
|
869
|
+
break;
|
|
870
|
+
case 'maxConcurrent':
|
|
871
|
+
live.maxConcurrent = Number(value) || 0;
|
|
872
|
+
break;
|
|
873
|
+
case 'rateLimit':
|
|
874
|
+
live.rateLimit = (value || { windowMs: 60_000, max: 120 });
|
|
875
|
+
break;
|
|
876
|
+
case 'blockExtensions':
|
|
877
|
+
live.blockExtensions = [...(value || [])];
|
|
878
|
+
break;
|
|
879
|
+
case 'trashDays':
|
|
880
|
+
live.trashDays = Number(value) || 0;
|
|
881
|
+
break;
|
|
882
|
+
case 'autoCleanDays':
|
|
883
|
+
live.autoCleanDays = Number(value) || 0;
|
|
884
|
+
break;
|
|
885
|
+
case 'autoCleanMaxSize':
|
|
886
|
+
live.autoCleanMaxSize = Number(value) || 0;
|
|
887
|
+
break;
|
|
888
|
+
default:
|
|
889
|
+
break;
|
|
890
|
+
}
|
|
891
|
+
// 口令变更后,此前的会话全部失效,当前会话保留(避免改完口令自己被踢下线)
|
|
892
|
+
if (key === 'password' || key === 'visitorPassword' || key === 'sessionTtl') {
|
|
893
|
+
auth.update({ password: live.password, visitorPassword: live.visitorPassword, sessionTtl: live.sessionTtl }, sessionTokenOf(req));
|
|
894
|
+
}
|
|
895
|
+
// 令牌变更:只作废「用令牌换来的会话」,口令登录的会话继续有效
|
|
896
|
+
if (key === 'token') {
|
|
897
|
+
auth.update({ token: live.token }, sessionTokenOf(req));
|
|
898
|
+
}
|
|
899
|
+
}
|
|
900
|
+
// 查看设置(仅管理员)
|
|
901
|
+
app.get('/localsend/api/settings', requireAdmin, (_req, res) => {
|
|
902
|
+
res.json({ code: 0, data: buildSettingsPayload() });
|
|
903
|
+
});
|
|
904
|
+
// 修改设置(仅管理员;开放模式下仅限本机)
|
|
905
|
+
app.post('/localsend/api/settings', requireSettingsWrite, express_1.default.json({ limit: '64kb' }), (req, res) => {
|
|
906
|
+
const changes = req.body?.changes;
|
|
907
|
+
if (!changes || typeof changes !== 'object' || Array.isArray(changes)) {
|
|
908
|
+
return void res.status(400).json({ code: 1, msg: '缺少要修改的配置项' });
|
|
909
|
+
}
|
|
910
|
+
const keys = Object.keys(changes);
|
|
911
|
+
for (const key of keys) {
|
|
912
|
+
if (!(key in settings_1.SETTING_DEFS))
|
|
913
|
+
return void res.status(400).json({ code: 1, msg: `未知的配置项:${key}` });
|
|
914
|
+
}
|
|
915
|
+
// 改口令需要再次验证当前管理员口令,防止会话被劫持后改掉口令
|
|
916
|
+
// 客户端提交的是当前口令的摘要,明文口令同样不上网
|
|
917
|
+
if ((keys.includes('password') || keys.includes('visitorPassword')) && !auth.verifyAdmin(req.body?.currentPasswordDigest)) {
|
|
918
|
+
return void res.status(403).json({ code: 1, msg: '当前管理员口令不正确', needAuth: true });
|
|
919
|
+
}
|
|
920
|
+
// 先全部校验通过再逐项生效,避免出现「改了一半」
|
|
921
|
+
const normalized = [];
|
|
922
|
+
for (const key of keys) {
|
|
923
|
+
const { value, error } = (0, settings_1.normalizeSetting)(key, changes[key]);
|
|
924
|
+
if (error)
|
|
925
|
+
return void res.status(400).json({ code: 1, msg: error });
|
|
926
|
+
normalized.push({ key, value });
|
|
927
|
+
}
|
|
928
|
+
for (const item of normalized) {
|
|
929
|
+
// 记录配置文件里的原值作为基准:之后若用户改了配置文件,以配置文件为准
|
|
930
|
+
settings.set(item.key, item.value, ls[item.key]);
|
|
931
|
+
applySetting(item.key, item.value, req);
|
|
932
|
+
}
|
|
933
|
+
get_logger_1.logger.log(console_log_colors_1.color.green('LocalSend 设置 :'.padStart(15, ' ')), console_log_colors_1.color.cyanBright(`已更新:${normalized.map((i) => i.key).join('、')}`));
|
|
934
|
+
// 只记改了哪些项,不记具体值(口令/令牌都在其中)
|
|
935
|
+
auditAction(req, res, 'settings.update', normalized.map((i) => i.key).join(','));
|
|
936
|
+
res.json({ code: 0, data: { applied: normalized.map((i) => i.key), ...buildSettingsPayload() } });
|
|
937
|
+
});
|
|
938
|
+
// 恢复某项设置为配置文件里的值(开放模式下同样仅限本机)
|
|
939
|
+
app.delete('/localsend/api/settings/:key', requireSettingsWrite, (req, res) => {
|
|
940
|
+
const key = String(req.params.key || '');
|
|
941
|
+
if (!(key in settings_1.SETTING_DEFS))
|
|
942
|
+
return void res.status(400).json({ code: 1, msg: '未知的配置项' });
|
|
943
|
+
settings.clear(key);
|
|
944
|
+
// 回到配置文件里的值(同样要走默认值归一化,否则未设置的项会变成 0)
|
|
945
|
+
applySetting(key, configValueOf(key), req);
|
|
946
|
+
get_logger_1.logger.log(console_log_colors_1.color.green('LocalSend 设置 :'.padStart(15, ' ')), console_log_colors_1.color.cyanBright(`已恢复默认:${key}`));
|
|
947
|
+
auditAction(req, res, 'settings.reset', key);
|
|
948
|
+
res.json({ code: 0, data: { applied: [key], ...buildSettingsPayload() } });
|
|
949
|
+
});
|
|
950
|
+
// ---------------------------------------------------------------------------
|
|
951
|
+
// 剪贴板内容落盘
|
|
952
|
+
//
|
|
953
|
+
// 分享只能分享「已经存在于存储目录里的文件」,
|
|
954
|
+
// 这里把纯文本与截图直接写成普通文件,
|
|
955
|
+
// 让「粘贴即分享」成为可能,同时继承列表、回收站、WebDAV 等全部能力。
|
|
956
|
+
// ---------------------------------------------------------------------------
|
|
957
|
+
app.post('/localsend/api/paste', requireWrite, express_1.default.json({ limit: '16mb' }), (req, res) => {
|
|
958
|
+
const parsed = (0, paste_1.parsePaste)(req.body);
|
|
959
|
+
if (parsed.error)
|
|
960
|
+
return void res.status(400).json({ code: 1, msg: parsed.error });
|
|
961
|
+
// 单个文件的体积限制,与上传保持一致
|
|
962
|
+
if (live.maxSize && parsed.buffer.length > live.maxSize) {
|
|
963
|
+
return void res.status(413).json({ code: 1, msg: `内容超出大小限制(${(live.maxSize / 1024 / 1024).toFixed(0)}MB)` });
|
|
964
|
+
}
|
|
965
|
+
// 总容量预检
|
|
966
|
+
if (live.maxTotalSize) {
|
|
967
|
+
const used = usedBytes();
|
|
968
|
+
if (used + parsed.buffer.length > live.maxTotalSize) {
|
|
969
|
+
return void res.status(413).json({
|
|
970
|
+
code: 1,
|
|
971
|
+
msg: `存储空间不足:已用 ${(used / 1024 / 1024).toFixed(1)}MB / ${(live.maxTotalSize / 1024 / 1024).toFixed(1)}MB`,
|
|
972
|
+
});
|
|
973
|
+
}
|
|
974
|
+
}
|
|
975
|
+
const hash = (0, paste_1.contentHash)(parsed.buffer);
|
|
976
|
+
const strategy = (0, paste_1.parseStrategy)(req.body?.strategy);
|
|
977
|
+
const fileName = (0, paste_1.buildPasteName)({ kind: parsed.kind, hash, stamp: (0, paste_1.timeStampTag)(), name: String(req.body?.name ?? ''), strategy }, parsed.ext);
|
|
978
|
+
// 与上传保持一致:粘贴同样不允许落盘可执行脚本(自定义文件名也不能绕过)
|
|
979
|
+
const pasteExt = (0, node_path_1.extname)(fileName).toLowerCase();
|
|
980
|
+
if (pasteExt && getBlockExts().has(pasteExt)) {
|
|
981
|
+
return void res.status(403).json({ code: 1, msg: `出于安全考虑,禁止保存 ${pasteExt} 类型的文件` });
|
|
982
|
+
}
|
|
983
|
+
// 目标目录:只允许落在存储目录内
|
|
984
|
+
const rawDir = String(req.body?.dir ?? '').trim();
|
|
985
|
+
const subDir = rawDir ? (0, path_1.safeRelPath)(rawDir) : '';
|
|
986
|
+
if (rawDir && !subDir)
|
|
987
|
+
return void res.status(400).json({ code: 1, msg: '非法的目标目录' });
|
|
988
|
+
const rel = subDir ? `${subDir}/${fileName}` : fileName;
|
|
989
|
+
const target = (0, path_1.resolveInDir)(dir, rel);
|
|
990
|
+
if (!target)
|
|
991
|
+
return void res.status(400).json({ code: 1, msg: '非法的文件路径' });
|
|
992
|
+
// 同名且内容一致时直接复用,避免粘贴同一段内容产生一堆重复文件
|
|
993
|
+
if ((0, node_fs_1.existsSync)(target) && (0, node_fs_1.statSync)(target).isFile()) {
|
|
994
|
+
try {
|
|
995
|
+
if ((0, paste_1.contentHash)((0, node_fs_1.readFileSync)(target)) === hash) {
|
|
996
|
+
return void res.json({ code: 0, data: { name: rel, size: parsed.buffer.length, hash, reused: true } });
|
|
997
|
+
}
|
|
998
|
+
}
|
|
999
|
+
catch {
|
|
1000
|
+
// 读取失败时按新文件处理
|
|
1001
|
+
}
|
|
1002
|
+
}
|
|
1003
|
+
// 同名但内容不同:追加 _1 后缀
|
|
1004
|
+
const finalRel = (0, manage_1.uniqueName)(dir, rel);
|
|
1005
|
+
const finalAbs = (0, path_1.resolveInDir)(dir, finalRel);
|
|
1006
|
+
if (!finalAbs)
|
|
1007
|
+
return void res.status(400).json({ code: 1, msg: '非法的文件路径' });
|
|
1008
|
+
try {
|
|
1009
|
+
if (!(0, node_fs_1.existsSync)((0, node_path_1.dirname)(finalAbs)))
|
|
1010
|
+
(0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(finalAbs), { recursive: true });
|
|
1011
|
+
(0, node_fs_1.writeFileSync)(finalAbs, parsed.buffer);
|
|
1012
|
+
}
|
|
1013
|
+
catch (err) {
|
|
1014
|
+
get_logger_1.logger.error('[localsend paste]', err);
|
|
1015
|
+
return void res.status(500).json({ code: 1, msg: '内容保存失败' });
|
|
1016
|
+
}
|
|
1017
|
+
res.json({ code: 0, data: { name: finalRel, size: parsed.buffer.length, hash, reused: false } });
|
|
1018
|
+
});
|
|
1019
|
+
// 创建分享链接
|
|
1020
|
+
app.post('/localsend/api/share', requireWrite, express_1.default.json({ limit: '256kb' }), (req, res) => {
|
|
1021
|
+
const names = Array.isArray(req.body?.names) ? req.body.names.map((n) => (0, path_1.safeRelPath)(n)).filter(Boolean) : [];
|
|
1022
|
+
if (!names.length)
|
|
1023
|
+
return void res.status(400).json({ code: 1, msg: '未指定要分享的文件' });
|
|
1024
|
+
const ttl = Math.min(Math.max(Number(req.body?.ttl) || 24 * 60 * 60, 60), 7 * 24 * 60 * 60);
|
|
1025
|
+
const { token, entry } = shareStore.create(names.slice(0, 100), ttl * 1000);
|
|
1026
|
+
auditAction(req, res, 'share.create', `${entry.names.length} 个文件`, { names: entry.names.slice(0, 5) });
|
|
1027
|
+
res.json({
|
|
1028
|
+
code: 0,
|
|
1029
|
+
data: {
|
|
1030
|
+
token,
|
|
1031
|
+
url: `/localsend/s/${token}`,
|
|
1032
|
+
expiresAt: entry.expiresAt,
|
|
1033
|
+
names: entry.names,
|
|
1034
|
+
},
|
|
1035
|
+
});
|
|
1036
|
+
});
|
|
1037
|
+
// 查看 / 撤销分享
|
|
1038
|
+
app.get('/localsend/api/share', (_req, res) => {
|
|
1039
|
+
res.json({
|
|
1040
|
+
code: 0,
|
|
1041
|
+
data: shareStore.list().map(({ token, entry }) => ({
|
|
1042
|
+
token,
|
|
1043
|
+
url: `/localsend/s/${token}`,
|
|
1044
|
+
names: entry.names,
|
|
1045
|
+
expiresAt: entry.expiresAt,
|
|
1046
|
+
hits: entry.hits,
|
|
1047
|
+
})),
|
|
1048
|
+
});
|
|
1049
|
+
});
|
|
1050
|
+
app.delete('/localsend/api/share/:token', requireAdmin, (req, res) => {
|
|
1051
|
+
const shareToken = String(req.params.token || '');
|
|
1052
|
+
const ok = shareStore.revoke(shareToken);
|
|
1053
|
+
if (ok)
|
|
1054
|
+
auditAction(req, res, 'share.revoke', shareToken.slice(0, 8));
|
|
1055
|
+
res.json({ code: ok ? 0 : 1, msg: ok ? '' : '分享不存在' });
|
|
1056
|
+
});
|
|
1057
|
+
// 页面:初始化时读入独立 html 单文件
|
|
1058
|
+
const pageHtml = (0, node_fs_1.readFileSync)((0, node_path_1.resolve)(__dirname, PAGE_REL_PATH), 'utf8');
|
|
1059
|
+
app.get('/localsend', (_req, res) => {
|
|
1060
|
+
res.type('html').send(pageHtml);
|
|
1061
|
+
});
|
|
1062
|
+
// 页面静态资源(图标、页面脚本等):与页面同目录,供离线局域网使用
|
|
1063
|
+
// 使用 ETag 协商缓存:升级后样式与页面版本始终一致,避免浏览器拿到旧的 CSS
|
|
1064
|
+
app.use('/localsend', express_1.default.static((0, node_path_1.resolve)(__dirname, PAGE_DIR), {
|
|
1065
|
+
index: false,
|
|
1066
|
+
maxAge: 0,
|
|
1067
|
+
etag: true,
|
|
1068
|
+
}));
|
|
1069
|
+
// 前端构建产物(tailwind 样式、vendor 第三方库):与源码分树存放,
|
|
1070
|
+
// 放在页面目录之后兜底,避免覆盖页面目录里的同名文件
|
|
1071
|
+
const assetsDir = resolveAssetsDir();
|
|
1072
|
+
if (assetsDir) {
|
|
1073
|
+
app.use('/localsend', express_1.default.static(assetsDir, {
|
|
1074
|
+
index: false,
|
|
1075
|
+
maxAge: 0,
|
|
1076
|
+
etag: true,
|
|
1077
|
+
}));
|
|
1078
|
+
}
|
|
1079
|
+
else {
|
|
1080
|
+
get_logger_1.logger.warn(`[localsend] 未找到前端构建产物,请先执行 ${console_log_colors_1.color.yellow('npm run build:assets')} 生成后再访问页面`);
|
|
1081
|
+
}
|
|
1082
|
+
// 文件列表(递归返回所有子目录下的文件,name 为相对路径)
|
|
1083
|
+
// 使用内存缓存 + fs.watch 增量更新,避免大目录每次请求都全量扫描
|
|
1084
|
+
// ------------------------------------------------------------------
|
|
1085
|
+
// 文件变化推送(SSE)
|
|
1086
|
+
//
|
|
1087
|
+
// 目录监听在缓存层已经就绪,这里把变更事件推给页面,
|
|
1088
|
+
// 让手机端能第一时间知道「收到了新文件」,不必手动刷新列表。
|
|
1089
|
+
// ------------------------------------------------------------------
|
|
1090
|
+
/** 已连接的 SSE 客户端 */
|
|
1091
|
+
const eventClients = new Set();
|
|
1092
|
+
/** 向所有客户端推送文件变更 */
|
|
1093
|
+
function broadcastChange(names) {
|
|
1094
|
+
if (!eventClients.size || !names.length)
|
|
1095
|
+
return;
|
|
1096
|
+
const payload = JSON.stringify({ names });
|
|
1097
|
+
for (const client of eventClients) {
|
|
1098
|
+
try {
|
|
1099
|
+
client.write(`event: changed\ndata: ${payload}\n\n`);
|
|
1100
|
+
}
|
|
1101
|
+
catch {
|
|
1102
|
+
eventClients.delete(client);
|
|
1103
|
+
}
|
|
1104
|
+
}
|
|
1105
|
+
}
|
|
1106
|
+
const listCache = (0, cache_1.createListCache)({
|
|
1107
|
+
dir,
|
|
1108
|
+
ttl: 5 * 60 * 1000,
|
|
1109
|
+
filter: (rel) => !(0, temp_1.isTempFileName)(rel.slice(rel.lastIndexOf('/') + 1)),
|
|
1110
|
+
onChange: broadcastChange,
|
|
1111
|
+
});
|
|
1112
|
+
// 启动即开始监听,保证没有列表请求时也能感知新文件
|
|
1113
|
+
listCache.startWatch();
|
|
1114
|
+
/**
|
|
1115
|
+
* 当前存储占用(字节,不含回收站与分片暂存)。
|
|
1116
|
+
*
|
|
1117
|
+
* 直接对列表缓存求和:缓存里本来就有全部文件的元信息,求和是内存操作。
|
|
1118
|
+
* 而每次上传都递归扫盘,在几千个文件时会明显拖慢请求;
|
|
1119
|
+
* 写操作结束后缓存会失效,下次访问自动重新校准。
|
|
1120
|
+
*/
|
|
1121
|
+
function usedBytes() {
|
|
1122
|
+
return listCache.list().reduce((sum, item) => sum + item.size, 0);
|
|
1123
|
+
}
|
|
1124
|
+
// SSE 长连接:页面订阅后实时接收文件变更
|
|
1125
|
+
app.get('/localsend/api/events', (req, res) => openEventStream(req, res));
|
|
1126
|
+
// 写操作完成后让列表缓存失效,保证下次请求能看到最新文件
|
|
1127
|
+
app.use('/localsend/api', (req, res, next) => {
|
|
1128
|
+
if (req.method === 'POST' || req.method === 'PUT' || req.method === 'DELETE') {
|
|
1129
|
+
res.on('finish', () => listCache.invalidate());
|
|
1130
|
+
}
|
|
1131
|
+
next();
|
|
1132
|
+
});
|
|
1133
|
+
// 文件列表(分页 + 搜索 + 筛选 + 排序)
|
|
1134
|
+
//
|
|
1135
|
+
// 文件多的时候一次性返回全量会让手机端卡顿,搜索也只能在前端做。
|
|
1136
|
+
// 这里把关键词、目录、扩展名、时间窗等条件全部下推到服务端,
|
|
1137
|
+
// 只返回当前页,同时给出筛选后的总数,供分页控件展示。
|
|
1138
|
+
app.get('/localsend/api/list', (req, res) => {
|
|
1139
|
+
const query = (0, query_1.parseListQuery)(req.query);
|
|
1140
|
+
const all = listCache.list();
|
|
1141
|
+
const filtered = (0, query_1.filterEntries)(all, query);
|
|
1142
|
+
const sorted = (0, query_1.sortEntries)(filtered, query.sort, query.asc);
|
|
1143
|
+
const result = (0, query_1.paginate)(sorted, query.page, query.pageSize);
|
|
1144
|
+
// allTotal 是不带任何筛选条件的文件总数,前端用来显示「筛选 N / 共 M」
|
|
1145
|
+
res.json({ code: 0, data: { ...result, allTotal: all.length } });
|
|
1146
|
+
});
|
|
1147
|
+
// 筛选选项(目录 / 扩展名)
|
|
1148
|
+
//
|
|
1149
|
+
// 服务端分页之后前端拿不到全量文件,无法再自己枚举目录,
|
|
1150
|
+
// 这里单独提供一个接口把可选项和各自的条目数返回给页面。
|
|
1151
|
+
app.get('/localsend/api/facets', (_req, res) => {
|
|
1152
|
+
const all = listCache.list();
|
|
1153
|
+
const { dirs, rootCount } = (0, query_1.collectDirs)(all);
|
|
1154
|
+
res.json({ code: 0, data: { dirs, rootCount, exts: (0, query_1.collectExts)(all), total: all.length } });
|
|
1155
|
+
});
|
|
1156
|
+
/**
|
|
1157
|
+
* 存储用量。
|
|
1158
|
+
*
|
|
1159
|
+
* 有配额却看不到用量时,用户只有在撞上 413 才知道「满了」。
|
|
1160
|
+
* 这里把已用、上限、文件数、回收站占用一起返回,页面画一条进度条即可。
|
|
1161
|
+
*/
|
|
1162
|
+
app.get('/localsend/api/usage', (_req, res) => {
|
|
1163
|
+
const entries = listCache.list();
|
|
1164
|
+
const used = entries.reduce((sum, item) => sum + item.size, 0);
|
|
1165
|
+
const trashEntries = trash.list();
|
|
1166
|
+
res.json({
|
|
1167
|
+
code: 0,
|
|
1168
|
+
data: {
|
|
1169
|
+
used,
|
|
1170
|
+
limit: live.maxTotalSize,
|
|
1171
|
+
files: entries.length,
|
|
1172
|
+
trash: trashEntries.reduce((sum, item) => sum + (item.size || 0), 0),
|
|
1173
|
+
trashCount: trashEntries.length,
|
|
1174
|
+
// 存储路径含用户名,属本机信息:只给管理员看
|
|
1175
|
+
dir: (0, auth_1.canManage)(res.locals.role) ? dir : '',
|
|
1176
|
+
trashDays: live.trashDays,
|
|
1177
|
+
autoCleanDays: live.autoCleanDays,
|
|
1178
|
+
maxSize: live.maxSize,
|
|
1179
|
+
},
|
|
1180
|
+
});
|
|
1181
|
+
});
|
|
1182
|
+
// 操作审计(仅管理员):回答「谁在什么时候改了什么」
|
|
1183
|
+
app.get('/localsend/api/audit', requireAdmin, (req, res) => {
|
|
1184
|
+
const limit = Math.min(Math.max(Number(req.query.limit) || 100, 1), 500);
|
|
1185
|
+
res.json({ code: 0, data: { file: audit.file, size: audit.size(), items: audit.recent(limit) } });
|
|
1186
|
+
});
|
|
1187
|
+
// 运行指标(仅管理员):诊断「传不上去 / 合并慢」时先看这里
|
|
1188
|
+
app.get('/localsend/api/stats', requireAdmin, (_req, res) => {
|
|
1189
|
+
const snap = metrics.snapshot();
|
|
1190
|
+
const cache = listCache.stats();
|
|
1191
|
+
res.json({
|
|
1192
|
+
code: 0,
|
|
1193
|
+
data: {
|
|
1194
|
+
uptime: Math.round((Date.now() - snap.startedAt) / 1000),
|
|
1195
|
+
memory: process.memoryUsage().rss,
|
|
1196
|
+
files: cache.entries,
|
|
1197
|
+
used: usedBytes(),
|
|
1198
|
+
cache: { hits: cache.hits, misses: cache.misses, watching: cache.watching, lastScan: cache.lastScan },
|
|
1199
|
+
guard: guard.stats(),
|
|
1200
|
+
events: eventClients.size,
|
|
1201
|
+
shares: shareStore.list().length,
|
|
1202
|
+
tickets: ticketStore.size(),
|
|
1203
|
+
counters: snap.counters,
|
|
1204
|
+
timers: snap.timers,
|
|
1205
|
+
audit: { file: audit.file, size: audit.size() },
|
|
1206
|
+
},
|
|
1207
|
+
});
|
|
1208
|
+
});
|
|
1209
|
+
// 多文件上传
|
|
1210
|
+
// 记录每个请求产生的临时文件,便于请求结束(含客户端中断)后清理残留
|
|
1211
|
+
const tempFiles = new WeakMap();
|
|
1212
|
+
// 单文件硬性上限:运行时把 maxSize 设为 0(不限制)时仍保留一道防线,避免磁盘被单个请求撑满
|
|
1213
|
+
const HARD_UPLOAD_LIMIT = 1024 * 1024 * 1024 * 1024;
|
|
1214
|
+
// 每次请求都按当前生效的 maxSize 创建 multer 实例,确保运行时修改立即生效
|
|
1215
|
+
/**
|
|
1216
|
+
* 本次上传的目标目录(相对存储目录,根目录为空串)。
|
|
1217
|
+
*
|
|
1218
|
+
* 页面在某个目录下上传时,文件应该落在这个目录里——
|
|
1219
|
+
* 以前一律写根目录,用户在「归档/2026」视图里上传完还得再移动一次。
|
|
1220
|
+
*/
|
|
1221
|
+
function uploadTargetRel(req) {
|
|
1222
|
+
const raw = String(req.query?.dir ?? '').trim();
|
|
1223
|
+
if (!raw || raw === query_1.ROOT_DIR)
|
|
1224
|
+
return '';
|
|
1225
|
+
return (0, path_1.safeRelPath)(raw);
|
|
1226
|
+
}
|
|
1227
|
+
/** 上传目标目录的绝对路径(目录不存在时创建) */
|
|
1228
|
+
function uploadTargetAbs(req) {
|
|
1229
|
+
const rel = uploadTargetRel(req);
|
|
1230
|
+
const abs = rel ? (0, path_1.resolveInDir)(dir, rel) : '';
|
|
1231
|
+
const target = abs || dir;
|
|
1232
|
+
if (!(0, node_fs_1.existsSync)(target))
|
|
1233
|
+
(0, node_fs_1.mkdirSync)(target, { recursive: true });
|
|
1234
|
+
return target;
|
|
1235
|
+
}
|
|
1236
|
+
const createUpload = () => (0, multer_1.default)({
|
|
1237
|
+
storage: multer_1.default.diskStorage({
|
|
1238
|
+
destination: (req, _file, cb) => cb(null, uploadTargetAbs(req)),
|
|
1239
|
+
filename: (req, _file, cb) => {
|
|
1240
|
+
const fileName = (0, node_crypto_1.randomBytes)(16).toString('hex');
|
|
1241
|
+
const set = tempFiles.get(req) || new Set();
|
|
1242
|
+
// 临时文件落在目标目录里,转正时同目录 rename 是最快的
|
|
1243
|
+
set.add((0, node_path_1.join)(uploadTargetAbs(req), fileName));
|
|
1244
|
+
tempFiles.set(req, set);
|
|
1245
|
+
cb(null, fileName);
|
|
1246
|
+
},
|
|
1247
|
+
}),
|
|
1248
|
+
limits: { fileSize: live.maxSize > 0 ? live.maxSize : HARD_UPLOAD_LIMIT, files: 200 },
|
|
1249
|
+
// 保留上传文件名的完整相对路径(上传文件夹时可保留目录结构)
|
|
1250
|
+
preservePath: true,
|
|
1251
|
+
// 显式声明按 latin1 读取 Content-Disposition 参数,保留文件名的原始字节,
|
|
1252
|
+
// 再由 decodeUploadName 按 utf-8 / gb18030 解码,避免中文文件名乱码
|
|
1253
|
+
defParamCharset: 'latin1',
|
|
1254
|
+
// 拦截可执行脚本,避免上传目录与静态服务根目录重叠时形成远程代码执行入口
|
|
1255
|
+
fileFilter: (_req, file, cb) => {
|
|
1256
|
+
const ext = (0, node_path_1.extname)(decodeUploadName(file.originalname)).toLowerCase();
|
|
1257
|
+
if (ext && getBlockExts().has(ext)) {
|
|
1258
|
+
cb(new LocalsendError(`出于安全考虑,禁止上传 ${ext} 类型的文件`, 403));
|
|
1259
|
+
return;
|
|
1260
|
+
}
|
|
1261
|
+
cb(null, true);
|
|
1262
|
+
},
|
|
1263
|
+
});
|
|
1264
|
+
app.post('/localsend/api/upload',
|
|
1265
|
+
// 写操作需要访客以上权限(只读访问不允许上传)
|
|
1266
|
+
requireWrite,
|
|
1267
|
+
// 单 IP 并发上传数限制
|
|
1268
|
+
guard.limitConcurrent,
|
|
1269
|
+
// 目标目录先校验:非法时直接拒绝,不能静默落到根目录
|
|
1270
|
+
(req, res, next) => {
|
|
1271
|
+
const raw = String(req.query?.dir ?? '').trim();
|
|
1272
|
+
if (raw && raw !== query_1.ROOT_DIR && !(0, path_1.safeRelPath)(raw)) {
|
|
1273
|
+
return void res.status(400).json({ code: 1, msg: '非法的目标目录' });
|
|
1274
|
+
}
|
|
1275
|
+
next();
|
|
1276
|
+
},
|
|
1277
|
+
// 总容量预检:目录已用容量与本次请求体大小共同判断,超出配额直接拒绝
|
|
1278
|
+
(req, res, next) => {
|
|
1279
|
+
if (!live.maxTotalSize)
|
|
1280
|
+
return next();
|
|
1281
|
+
const used = usedBytes();
|
|
1282
|
+
// 记录写入前的占用,写入后复核时用它加上本次实际写入量
|
|
1283
|
+
res.locals.usedBefore = used;
|
|
1284
|
+
if (used >= live.maxTotalSize) {
|
|
1285
|
+
res.status(413).json({
|
|
1286
|
+
code: 1,
|
|
1287
|
+
msg: `存储空间已满:${(used / 1024 / 1024).toFixed(1)}MB / ${(live.maxTotalSize / 1024 / 1024).toFixed(1)}MB`,
|
|
1288
|
+
});
|
|
1289
|
+
return;
|
|
1290
|
+
}
|
|
1291
|
+
// multipart 请求体的 Content-Length 包含少量协议开销,作为保守估计
|
|
1292
|
+
const need = Number(req.get('Content-Length') || 0);
|
|
1293
|
+
if (need > 0 && used + need > live.maxTotalSize) {
|
|
1294
|
+
res.status(413).json({
|
|
1295
|
+
code: 1,
|
|
1296
|
+
msg: `剩余容量不足:已用 ${(used / 1024 / 1024).toFixed(1)}MB,本次需要约 ${(need / 1024 / 1024).toFixed(1)}MB`,
|
|
1297
|
+
});
|
|
1298
|
+
return;
|
|
1299
|
+
}
|
|
1300
|
+
next();
|
|
1301
|
+
},
|
|
1302
|
+
// 按请求创建,使 maxSize 的运行时修改立即生效
|
|
1303
|
+
(req, res, next) => createUpload().array('files')(req, res, next), (req, res) => {
|
|
1304
|
+
const files = (req.files || []);
|
|
1305
|
+
const results = [];
|
|
1306
|
+
const errors = [];
|
|
1307
|
+
const temps = tempFiles.get(req);
|
|
1308
|
+
// 请求结束(含客户端中断)后清理未转正的临时文件,避免残留占用空间
|
|
1309
|
+
res.on('close', () => {
|
|
1310
|
+
if (!temps)
|
|
1311
|
+
return;
|
|
1312
|
+
for (const tempPath of temps) {
|
|
1313
|
+
try {
|
|
1314
|
+
(0, node_fs_1.rmSync)(tempPath, { force: true });
|
|
1315
|
+
}
|
|
1316
|
+
catch {
|
|
1317
|
+
// 忽略清理失败
|
|
1318
|
+
}
|
|
1319
|
+
}
|
|
1320
|
+
temps.clear();
|
|
1321
|
+
});
|
|
1322
|
+
const targetRel = uploadTargetRel(req);
|
|
1323
|
+
for (const f of files) {
|
|
1324
|
+
try {
|
|
1325
|
+
// 文件名可能是带目录的相对路径(上传文件夹时保留结构)
|
|
1326
|
+
const rel = (0, path_1.safeRelPath)(decodeUploadName(f.originalname)) || `file_${Date.now()}`;
|
|
1327
|
+
// 目标目录来自页面当前视图:在「归档/2026」里上传就落在该目录
|
|
1328
|
+
const fullRel = targetRel ? `${targetRel}/${rel}` : rel;
|
|
1329
|
+
const name = (0, manage_1.uniqueName)(dir, fullRel);
|
|
1330
|
+
const target = (0, path_1.resolveInDir)(dir, name);
|
|
1331
|
+
if (!target)
|
|
1332
|
+
throw new Error(`非法的文件路径:${rel}`);
|
|
1333
|
+
const subDir = (0, node_path_1.dirname)(target);
|
|
1334
|
+
if (!(0, node_fs_1.existsSync)(subDir))
|
|
1335
|
+
(0, node_fs_1.mkdirSync)(subDir, { recursive: true });
|
|
1336
|
+
(0, node_fs_1.renameSync)(f.path, target);
|
|
1337
|
+
temps?.delete(f.path);
|
|
1338
|
+
results.push({ name, size: f.size });
|
|
1339
|
+
}
|
|
1340
|
+
catch (err) {
|
|
1341
|
+
get_logger_1.logger.error('[localsend upload]', err);
|
|
1342
|
+
errors.push(f.originalname || '');
|
|
1343
|
+
}
|
|
1344
|
+
}
|
|
1345
|
+
// 容量复核:写入后若超出总配额,撤销本次写入并提示。
|
|
1346
|
+
// 用「写入前占用 + 本次写入量」判断,避免缓存还没失效时读到旧值
|
|
1347
|
+
const written = results.reduce((sum, item) => sum + item.size, 0);
|
|
1348
|
+
const usedBefore = Number(res.locals.usedBefore) || 0;
|
|
1349
|
+
if (live.maxTotalSize && usedBefore + written > live.maxTotalSize) {
|
|
1350
|
+
for (const r of results) {
|
|
1351
|
+
try {
|
|
1352
|
+
(0, node_fs_1.rmSync)((0, node_path_1.join)(dir, r.name));
|
|
1353
|
+
}
|
|
1354
|
+
catch {
|
|
1355
|
+
// 忽略删除失败
|
|
1356
|
+
}
|
|
1357
|
+
}
|
|
1358
|
+
metrics.inc('upload.rejected');
|
|
1359
|
+
res.status(413).json({ code: 1, msg: '存储容量不足,本次上传已撤销' });
|
|
1360
|
+
return;
|
|
1361
|
+
}
|
|
1362
|
+
metrics.inc('upload.request');
|
|
1363
|
+
if (results.length) {
|
|
1364
|
+
metrics.inc('upload.file', results.length);
|
|
1365
|
+
// 上传太频繁,只记「一次请求」的概要,不逐文件写审计
|
|
1366
|
+
auditAction(req, res, 'file.upload', `${results.length} 个文件`, { names: results.slice(0, 5).map((item) => item.name) });
|
|
1367
|
+
}
|
|
1368
|
+
if (errors.length)
|
|
1369
|
+
metrics.inc('upload.error', errors.length);
|
|
1370
|
+
res.json({ code: 0, data: { results, errors } });
|
|
1371
|
+
});
|
|
1372
|
+
// ---------------------------------------------------------------------------
|
|
1373
|
+
// 分片上传(断点续传)
|
|
1374
|
+
//
|
|
1375
|
+
// 大文件弱网传输常中途断开,整包重传代价大。这里把文件切成定长分片逐片上传,
|
|
1376
|
+
// 服务端暂存分片;客户端断线重连后查询已上传分片,只补传缺失部分。
|
|
1377
|
+
// ---------------------------------------------------------------------------
|
|
1378
|
+
const chunkTmpDir = (0, node_path_1.join)(dir, '.chunks');
|
|
1379
|
+
const chunkStore = (0, chunk_1.createChunkStore)({
|
|
1380
|
+
dir,
|
|
1381
|
+
tmpDir: chunkTmpDir,
|
|
1382
|
+
maxSize: () => live.maxSize,
|
|
1383
|
+
ttl: 24 * 60 * 60 * 1000,
|
|
1384
|
+
});
|
|
1385
|
+
/** 分片上传同样禁止服务端脚本类型 */
|
|
1386
|
+
const chunkBlockExt = (name) => {
|
|
1387
|
+
const ext = (0, node_path_1.extname)(name).toLowerCase();
|
|
1388
|
+
return !!ext && getBlockExts().has(ext);
|
|
1389
|
+
};
|
|
1390
|
+
// 初始化上传任务
|
|
1391
|
+
app.post('/localsend/api/chunk/init', requireWrite, express_1.default.json({ limit: '64kb' }), (req, res) => {
|
|
1392
|
+
const name = decodeUploadName(req.body?.name);
|
|
1393
|
+
const rel = (0, path_1.safeRelPath)(name);
|
|
1394
|
+
if (!rel)
|
|
1395
|
+
return void res.status(400).json({ code: 1, msg: '非法的文件名' });
|
|
1396
|
+
if (chunkBlockExt(rel)) {
|
|
1397
|
+
return void res.status(403).json({ code: 1, msg: `出于安全考虑,禁止上传 ${(0, node_path_1.extname)(rel).toLowerCase()} 类型的文件` });
|
|
1398
|
+
}
|
|
1399
|
+
const size = Number(req.body?.size) || 0;
|
|
1400
|
+
if (size < 0)
|
|
1401
|
+
return void res.status(400).json({ code: 1, msg: '非法的文件大小' });
|
|
1402
|
+
if (live.maxSize && size > live.maxSize) {
|
|
1403
|
+
return void res.status(413).json({ code: 1, msg: `文件超出大小限制(${(live.maxSize / 1024 / 1024).toFixed(0)}MB)` });
|
|
1404
|
+
}
|
|
1405
|
+
const chunkSize = chunkStore.clampChunkSize(req.body?.chunkSize);
|
|
1406
|
+
// 续传:客户端带上一次的任务 ID,或文件指纹(名称:大小:修改时间),服务端据此复用任务
|
|
1407
|
+
const uploadId = typeof req.body?.uploadId === 'string' ? req.body.uploadId : '';
|
|
1408
|
+
const fileKey = typeof req.body?.fileKey === 'string' ? req.body.fileKey : '';
|
|
1409
|
+
const result = chunkStore.init(rel, size, chunkSize, { uploadId, fileKey });
|
|
1410
|
+
res.json({ code: 0, data: result });
|
|
1411
|
+
});
|
|
1412
|
+
// 上传单个分片(multipart,字段名 chunk;分片序号放在查询参数里)
|
|
1413
|
+
// 使用独立的 multer 实例,分片直接落到暂存目录,不经过存储目录根
|
|
1414
|
+
const chunkUpload = (0, multer_1.default)({
|
|
1415
|
+
storage: multer_1.default.diskStorage({
|
|
1416
|
+
destination: (_req, _file, cb) => {
|
|
1417
|
+
if (!(0, node_fs_1.existsSync)(chunkTmpDir))
|
|
1418
|
+
(0, node_fs_1.mkdirSync)(chunkTmpDir, { recursive: true });
|
|
1419
|
+
cb(null, chunkTmpDir);
|
|
1420
|
+
},
|
|
1421
|
+
filename: (_req, _file, cb) => cb(null, `incoming-${(0, node_crypto_1.randomBytes)(16).toString('hex')}`),
|
|
1422
|
+
}),
|
|
1423
|
+
limits: { fileSize: chunk_1.MAX_CHUNK_SIZE, files: 1 },
|
|
1424
|
+
});
|
|
1425
|
+
app.post('/localsend/api/chunk/upload', requireWrite,
|
|
1426
|
+
// 分片上传有自己的并发预算:一个文件就开 3 个分片任务,
|
|
1427
|
+
// 沿用文件级并发数(默认 3)会让并发分片互相挤掉
|
|
1428
|
+
guard.limitConcurrentChunk, chunkUpload.single('chunk'), (req, res) => {
|
|
1429
|
+
const uploadId = String(req.query.uploadId || '');
|
|
1430
|
+
const index = Number(req.query.index);
|
|
1431
|
+
const file = req.file;
|
|
1432
|
+
if (!uploadId || !file) {
|
|
1433
|
+
if (file?.path)
|
|
1434
|
+
(0, node_fs_1.rmSync)(file.path, { force: true });
|
|
1435
|
+
return void res.status(400).json({ code: 1, msg: '缺少 uploadId 或分片数据' });
|
|
1436
|
+
}
|
|
1437
|
+
const meta = chunkStore.meta(uploadId);
|
|
1438
|
+
if (!meta) {
|
|
1439
|
+
(0, node_fs_1.rmSync)(file.path, { force: true });
|
|
1440
|
+
return void res.status(404).json({ code: 1, msg: '上传任务不存在或已过期' });
|
|
1441
|
+
}
|
|
1442
|
+
if (!Number.isInteger(index) || index < 0 || index >= meta.total) {
|
|
1443
|
+
(0, node_fs_1.rmSync)(file.path, { force: true });
|
|
1444
|
+
return void res.status(400).json({ code: 1, msg: '非法的分片序号' });
|
|
1445
|
+
}
|
|
1446
|
+
// 把落下的分片登记到暂存区
|
|
1447
|
+
const result = chunkStore.writeChunk(uploadId, index, file.path);
|
|
1448
|
+
if (!result) {
|
|
1449
|
+
(0, node_fs_1.rmSync)(file.path, { force: true });
|
|
1450
|
+
return void res.status(404).json({ code: 1, msg: '上传任务不存在或已过期' });
|
|
1451
|
+
}
|
|
1452
|
+
res.json({ code: 0, data: result });
|
|
1453
|
+
});
|
|
1454
|
+
// 查询上传进度(断点续传的关键)
|
|
1455
|
+
app.get('/localsend/api/chunk/status', (req, res) => {
|
|
1456
|
+
const uploadId = String(req.query.uploadId || '');
|
|
1457
|
+
const result = chunkStore.status(uploadId);
|
|
1458
|
+
if (!result)
|
|
1459
|
+
return void res.status(404).json({ code: 1, msg: '上传任务不存在或已过期' });
|
|
1460
|
+
res.json({ code: 0, data: result });
|
|
1461
|
+
});
|
|
1462
|
+
// 合并分片为正式文件(流式写入,不阻塞事件循环)
|
|
1463
|
+
app.post('/localsend/api/chunk/merge', requireWrite, async (req, res) => {
|
|
1464
|
+
const uploadId = String(req.query.uploadId || '');
|
|
1465
|
+
const meta = chunkStore.meta(uploadId);
|
|
1466
|
+
if (!meta)
|
|
1467
|
+
return void res.status(404).json({ code: 1, msg: '上传任务不存在或已过期' });
|
|
1468
|
+
// 合并前复核总配额
|
|
1469
|
+
if (live.maxTotalSize) {
|
|
1470
|
+
const used = usedBytes();
|
|
1471
|
+
if (used + meta.size > live.maxTotalSize) {
|
|
1472
|
+
return void res.status(413).json({
|
|
1473
|
+
code: 1,
|
|
1474
|
+
msg: `存储空间不足:已用 ${(used / 1024 / 1024).toFixed(1)}MB / ${(live.maxTotalSize / 1024 / 1024).toFixed(1)}MB`,
|
|
1475
|
+
});
|
|
1476
|
+
}
|
|
1477
|
+
}
|
|
1478
|
+
const mergeStarted = Date.now();
|
|
1479
|
+
const result = await chunkStore.merge(uploadId, (name) => {
|
|
1480
|
+
const finalName = (0, manage_1.uniqueName)(dir, name);
|
|
1481
|
+
const target = (0, path_1.resolveInDir)(dir, finalName);
|
|
1482
|
+
if (!target)
|
|
1483
|
+
return null;
|
|
1484
|
+
const subDir = (0, node_path_1.dirname)(target);
|
|
1485
|
+
if (!(0, node_fs_1.existsSync)(subDir))
|
|
1486
|
+
(0, node_fs_1.mkdirSync)(subDir, { recursive: true });
|
|
1487
|
+
return { path: target, name: finalName };
|
|
1488
|
+
});
|
|
1489
|
+
metrics.observe('merge.ms', Date.now() - mergeStarted);
|
|
1490
|
+
if (!result) {
|
|
1491
|
+
metrics.inc('merge.fail');
|
|
1492
|
+
return void res.status(400).json({ code: 1, msg: '分片不完整,无法合并' });
|
|
1493
|
+
}
|
|
1494
|
+
metrics.inc('merge.ok');
|
|
1495
|
+
metrics.inc('upload.file');
|
|
1496
|
+
auditAction(req, res, 'file.upload', result.name, { chunks: meta.total, size: result.size, mode: 'chunk' });
|
|
1497
|
+
res.json({ code: 0, data: result });
|
|
1498
|
+
});
|
|
1499
|
+
// 取消上传并清理分片
|
|
1500
|
+
app.delete('/localsend/api/chunk/cancel', requireWrite, (req, res) => {
|
|
1501
|
+
const uploadId = String(req.query.uploadId || '');
|
|
1502
|
+
const ok = chunkStore.cancel(uploadId);
|
|
1503
|
+
res.json({ code: ok ? 0 : 1, msg: ok ? '' : '上传任务不存在' });
|
|
1504
|
+
});
|
|
1505
|
+
// ---------------------------------------------------------------------------
|
|
1506
|
+
// 传输测速
|
|
1507
|
+
//
|
|
1508
|
+
// 局域网速度受路由器、频段和负载影响很大,用户需要一个直观的方式
|
|
1509
|
+
// 判断当前链路质量:下载方向直接推数据,上传方向接收后立即丢弃。
|
|
1510
|
+
// ---------------------------------------------------------------------------
|
|
1511
|
+
// 下载测速:GET /localsend/api/speed?size=10(单位 MB,1~100,默认 10)
|
|
1512
|
+
app.get('/localsend/api/speed', (req, res) => {
|
|
1513
|
+
const mb = Math.min(Math.max(Number(req.query.size) || 10, 1), 100);
|
|
1514
|
+
const size = mb * 1024 * 1024;
|
|
1515
|
+
res.set({
|
|
1516
|
+
'Content-Type': 'application/octet-stream',
|
|
1517
|
+
'Content-Length': String(size),
|
|
1518
|
+
'Cache-Control': 'no-store',
|
|
1519
|
+
});
|
|
1520
|
+
// 固定内容的数据块,循环输出即可,无需生成随机数
|
|
1521
|
+
const block = Buffer.alloc(256 * 1024, 0x61);
|
|
1522
|
+
let sent = 0;
|
|
1523
|
+
const pump = () => {
|
|
1524
|
+
while (sent < size) {
|
|
1525
|
+
const n = Math.min(block.length, size - sent);
|
|
1526
|
+
sent += n;
|
|
1527
|
+
if (!res.write(n === block.length ? block : block.subarray(0, n))) {
|
|
1528
|
+
res.once('drain', pump);
|
|
1529
|
+
return;
|
|
1530
|
+
}
|
|
1531
|
+
}
|
|
1532
|
+
res.end();
|
|
1533
|
+
};
|
|
1534
|
+
pump();
|
|
1535
|
+
});
|
|
1536
|
+
// 上传测速:POST /localsend/api/speed(接收请求体并丢弃,不落盘)
|
|
1537
|
+
app.post('/localsend/api/speed', (req, res) => {
|
|
1538
|
+
const start = Date.now();
|
|
1539
|
+
let bytes = 0;
|
|
1540
|
+
req.on('data', (chunk) => {
|
|
1541
|
+
bytes += chunk.length;
|
|
1542
|
+
});
|
|
1543
|
+
req.on('end', () => {
|
|
1544
|
+
res.json({ code: 0, data: { bytes, ms: Date.now() - start } });
|
|
1545
|
+
});
|
|
1546
|
+
req.on('error', () => {
|
|
1547
|
+
if (!res.headersSent)
|
|
1548
|
+
res.status(400).json({ code: 1, msg: '测速数据接收失败' });
|
|
1549
|
+
});
|
|
1550
|
+
});
|
|
1551
|
+
/**
|
|
1552
|
+
* 换票:为下载 / 预览 / 打包 / 事件流签发一张短期票据。
|
|
1553
|
+
*
|
|
1554
|
+
* 票据只对本次列出的文件有效,几分钟后自动失效,
|
|
1555
|
+
* 因此可以安全地放进 URL(<img src>、<a download>、EventSource 都带不了请求头)。
|
|
1556
|
+
*/
|
|
1557
|
+
app.post('/localsend/api/ticket', express_1.default.json({ limit: '64kb' }), (req, res) => {
|
|
1558
|
+
const raw = String(req.body?.scope || 'download');
|
|
1559
|
+
const scope = raw === 'preview' || raw === 'zip' || raw === 'events' ? raw : 'download';
|
|
1560
|
+
if (scope === 'events') {
|
|
1561
|
+
const entry = ticketStore.issue('events');
|
|
1562
|
+
return void res.json({ code: 0, data: { token: entry.token, scope, expiresAt: entry.expiresAt } });
|
|
1563
|
+
}
|
|
1564
|
+
const names = (Array.isArray(req.body?.names) ? req.body.names : []).map((item) => (0, path_1.safeRelPath)(item)).filter(Boolean);
|
|
1565
|
+
if (!names.length)
|
|
1566
|
+
return void res.status(400).json({ code: 1, msg: '未指定要访问的文件' });
|
|
1567
|
+
// 只对真实存在的文件发票据:顺带杜绝用票据接口探测路径
|
|
1568
|
+
for (const rel of names) {
|
|
1569
|
+
const filePath = (0, path_1.resolveInDir)(dir, rel);
|
|
1570
|
+
if (!filePath || !(0, node_fs_1.existsSync)(filePath) || !(0, node_fs_1.statSync)(filePath).isFile()) {
|
|
1571
|
+
return void res.status(404).json({ code: 1, msg: `文件不存在:${rel}` });
|
|
1572
|
+
}
|
|
1573
|
+
}
|
|
1574
|
+
const entry = ticketStore.issue(scope, names);
|
|
1575
|
+
res.json({ code: 0, data: { token: entry.token, scope, expiresAt: entry.expiresAt } });
|
|
1576
|
+
});
|
|
1577
|
+
// 下载。dotfiles: 'allow' 以兼容 ~/.static-server 这类隐藏目录作为存储目录
|
|
1578
|
+
app.get('/localsend/api/download/*name', (req, res) => {
|
|
1579
|
+
const rel = relParam(req);
|
|
1580
|
+
if (!rel)
|
|
1581
|
+
return void res.status(400).json({ code: 1, msg: '非法的文件路径' });
|
|
1582
|
+
sendDownloadResponse(res, rel);
|
|
1583
|
+
});
|
|
1584
|
+
// 预览(inline 方式返回,浏览器可直读图片/文本等)
|
|
1585
|
+
app.get('/localsend/api/preview/*name', (req, res) => {
|
|
1586
|
+
const rel = relParam(req);
|
|
1587
|
+
if (!rel)
|
|
1588
|
+
return void res.status(400).json({ code: 1, msg: '非法的文件路径' });
|
|
1589
|
+
sendPreviewResponse(res, rel);
|
|
1590
|
+
});
|
|
1591
|
+
// 删除(移入回收站,可还原)
|
|
1592
|
+
app.delete('/localsend/api/delete/*name', requireAdmin, (req, res) => {
|
|
1593
|
+
const rel = relParam(req);
|
|
1594
|
+
if (!rel)
|
|
1595
|
+
return void res.status(400).json({ code: 1, msg: '非法的文件路径' });
|
|
1596
|
+
const filePath = (0, path_1.resolveInDir)(dir, rel);
|
|
1597
|
+
if (!filePath || !(0, node_fs_1.existsSync)(filePath))
|
|
1598
|
+
return void res.status(404).json({ code: 1, msg: '文件不存在' });
|
|
1599
|
+
const entry = trash.add(rel);
|
|
1600
|
+
if (!entry) {
|
|
1601
|
+
// 移入回收站失败时退化为直接删除
|
|
1602
|
+
try {
|
|
1603
|
+
(0, node_fs_1.rmSync)(filePath);
|
|
1604
|
+
}
|
|
1605
|
+
catch {
|
|
1606
|
+
return void res.status(500).json({ code: 1, msg: '删除失败' });
|
|
1607
|
+
}
|
|
1608
|
+
auditAction(req, res, 'file.delete', rel, { trashed: false });
|
|
1609
|
+
return void res.json({ code: 0, data: { trashed: false } });
|
|
1610
|
+
}
|
|
1611
|
+
auditAction(req, res, 'file.delete', rel, { trashed: true });
|
|
1612
|
+
res.json({ code: 0, data: { trashed: true, id: entry.id, name: entry.name } });
|
|
1613
|
+
});
|
|
1614
|
+
// 回收站:列出条目
|
|
1615
|
+
app.get('/localsend/api/trash', (_req, res) => {
|
|
1616
|
+
res.json({ code: 0, data: trash.list() });
|
|
1617
|
+
});
|
|
1618
|
+
// 回收站:还原
|
|
1619
|
+
app.post('/localsend/api/trash/:id/restore', requireAdmin, (req, res) => {
|
|
1620
|
+
const id = String(req.params.id || '');
|
|
1621
|
+
const restored = trash.restore(id);
|
|
1622
|
+
if (!restored)
|
|
1623
|
+
return void res.status(404).json({ code: 1, msg: '回收站条目不存在或已过期' });
|
|
1624
|
+
auditAction(req, res, 'trash.restore', restored);
|
|
1625
|
+
res.json({ code: 0, data: { name: restored } });
|
|
1626
|
+
});
|
|
1627
|
+
// 回收站:彻底删除
|
|
1628
|
+
app.delete('/localsend/api/trash/:id', requireAdmin, (req, res) => {
|
|
1629
|
+
const id = String(req.params.id || '');
|
|
1630
|
+
const ok = trash.remove(id);
|
|
1631
|
+
if (ok)
|
|
1632
|
+
auditAction(req, res, 'trash.delete', id);
|
|
1633
|
+
res.json({ code: ok ? 0 : 1, msg: ok ? '' : '回收站条目不存在' });
|
|
1634
|
+
});
|
|
1635
|
+
// 回收站:清空
|
|
1636
|
+
app.delete('/localsend/api/trash', requireAdmin, (req, res) => {
|
|
1637
|
+
const count = trash.empty();
|
|
1638
|
+
auditAction(req, res, 'trash.empty', `${count} 个`);
|
|
1639
|
+
res.json({ code: 0, data: { removed: count } });
|
|
1640
|
+
});
|
|
1641
|
+
// 批量打包下载:把多个文件流式打成 zip(不落盘、不占额外磁盘)
|
|
1642
|
+
app.get('/localsend/api/zip', async (req, res) => {
|
|
1643
|
+
const names = String(req.query.names || '')
|
|
1644
|
+
.split(',')
|
|
1645
|
+
.map((n) => (0, path_1.safeRelPath)(n))
|
|
1646
|
+
.filter(Boolean);
|
|
1647
|
+
if (!names.length)
|
|
1648
|
+
return void res.status(400).json({ code: 1, msg: '未指定要打包的文件' });
|
|
1649
|
+
await sendZipResponse(res, names);
|
|
1650
|
+
});
|
|
1651
|
+
// ---------------------------------------------------------------------------
|
|
1652
|
+
// 文件整理(纯文件操作)
|
|
1653
|
+
//
|
|
1654
|
+
// 只改真实目录结构,不引入任何元数据存储,
|
|
1655
|
+
// 因此整理完的文件在回收站、分享链接、WebDAV 里都能直接看到。
|
|
1656
|
+
// ---------------------------------------------------------------------------
|
|
1657
|
+
// 重命名 / 移动单个文件(to 带目录即为移动)
|
|
1658
|
+
app.post('/localsend/api/rename', requireAdmin, express_1.default.json({ limit: '64kb' }), (req, res) => {
|
|
1659
|
+
const from = String(req.body?.from ?? '');
|
|
1660
|
+
const to = String(req.body?.to ?? '');
|
|
1661
|
+
const result = (0, manage_1.renameFile)(dir, from, to);
|
|
1662
|
+
if (result.code !== 0)
|
|
1663
|
+
return void res.status(400).json({ code: 1, msg: result.msg });
|
|
1664
|
+
auditAction(req, res, 'file.rename', `${result.from} → ${result.to}`);
|
|
1665
|
+
res.json({ code: 0, data: { from: result.from, to: result.to } });
|
|
1666
|
+
});
|
|
1667
|
+
// 批量移动到指定目录
|
|
1668
|
+
app.post('/localsend/api/move', requireAdmin, express_1.default.json({ limit: '1mb' }), (req, res) => {
|
|
1669
|
+
const names = Array.isArray(req.body?.names) ? req.body.names : [];
|
|
1670
|
+
if (!names.length)
|
|
1671
|
+
return void res.status(400).json({ code: 1, msg: '未指定要移动的文件' });
|
|
1672
|
+
const rawDir = String(req.body?.dir ?? '').trim();
|
|
1673
|
+
// 目标目录非法时直接拒绝,避免把文件挪到存储目录之外
|
|
1674
|
+
if (rawDir && rawDir !== query_1.ROOT_DIR && !(0, path_1.safeRelPath)(rawDir)) {
|
|
1675
|
+
return void res.status(400).json({ code: 1, msg: '非法的目标目录' });
|
|
1676
|
+
}
|
|
1677
|
+
const result = (0, manage_1.moveFiles)(dir, names, rawDir);
|
|
1678
|
+
auditAction(req, res, 'file.move', `${result.moved.length} 个 → ${rawDir || '根目录'}`, {
|
|
1679
|
+
names: result.moved.slice(0, 5).map((item) => item.from),
|
|
1680
|
+
});
|
|
1681
|
+
res.json({ code: 0, data: result });
|
|
1682
|
+
});
|
|
1683
|
+
// 按规则批量重命名
|
|
1684
|
+
app.post('/localsend/api/rename-batch', requireAdmin, express_1.default.json({ limit: '1mb' }), (req, res) => {
|
|
1685
|
+
const names = Array.isArray(req.body?.names) ? req.body.names : [];
|
|
1686
|
+
if (!names.length)
|
|
1687
|
+
return void res.status(400).json({ code: 1, msg: '未指定要重命名的文件' });
|
|
1688
|
+
const rule = (0, manage_1.parseRenameRule)(req.body?.rule);
|
|
1689
|
+
const result = (0, manage_1.batchRename)(dir, names, rule);
|
|
1690
|
+
auditAction(req, res, 'file.rename-batch', `${result.renamed.length} 个`, { rule: rule.mode });
|
|
1691
|
+
res.json({ code: 0, data: result });
|
|
1692
|
+
});
|
|
1693
|
+
// 批量删除
|
|
1694
|
+
app.post('/localsend/api/delete-batch',
|
|
1695
|
+
// 批量删除属于危险操作,需要管理员权限
|
|
1696
|
+
requireAdmin,
|
|
1697
|
+
// 本模块未启用全局 JSON 解析,这里单独挂载
|
|
1698
|
+
express_1.default.json({ limit: '1mb' }), (req, res) => {
|
|
1699
|
+
const names = Array.isArray(req.body?.names) ? req.body.names : [];
|
|
1700
|
+
const deleted = [];
|
|
1701
|
+
const failed = [];
|
|
1702
|
+
for (const item of names.slice(0, 500)) {
|
|
1703
|
+
const rel = (0, path_1.safeRelPath)(item);
|
|
1704
|
+
const filePath = rel ? (0, path_1.resolveInDir)(dir, rel) : '';
|
|
1705
|
+
if (!filePath || !(0, node_fs_1.existsSync)(filePath)) {
|
|
1706
|
+
failed.push(String(item));
|
|
1707
|
+
continue;
|
|
1708
|
+
}
|
|
1709
|
+
try {
|
|
1710
|
+
// 优先移入回收站,失败时退化为直接删除
|
|
1711
|
+
if (!trash.add(rel))
|
|
1712
|
+
(0, node_fs_1.rmSync)(filePath);
|
|
1713
|
+
deleted.push(rel);
|
|
1714
|
+
}
|
|
1715
|
+
catch (err) {
|
|
1716
|
+
get_logger_1.logger.error('[localsend 删除]', err);
|
|
1717
|
+
failed.push(rel);
|
|
1718
|
+
}
|
|
1719
|
+
}
|
|
1720
|
+
auditAction(req, res, 'file.delete-batch', `${deleted.length} 个`, { names: deleted.slice(0, 5), failed: failed.length });
|
|
1721
|
+
res.json({ code: 0, data: { deleted, failed } });
|
|
1722
|
+
});
|
|
1723
|
+
// 清理上传残留的临时文件(上传中断时可能留下无扩展名的哈希文件)
|
|
1724
|
+
app.post('/localsend/api/cleanup-temp', requireAdmin, (req, res) => {
|
|
1725
|
+
const removed = (0, temp_1.cleanupTempFiles)(dir);
|
|
1726
|
+
if (removed.length)
|
|
1727
|
+
auditAction(req, res, 'file.cleanup-temp', `${removed.length} 个`);
|
|
1728
|
+
res.json({ code: 0, data: { removed: removed.length } });
|
|
1729
|
+
});
|
|
1730
|
+
// 统一错误处理:把上传失败、文件超限、类型拦截等转成友好的 JSON 提示
|
|
1731
|
+
app.use('/localsend', (err, _req, res, next) => {
|
|
1732
|
+
if (res.headersSent)
|
|
1733
|
+
return next(err);
|
|
1734
|
+
let status = 500;
|
|
1735
|
+
let msg = err?.message || '请求处理失败';
|
|
1736
|
+
if (err instanceof LocalsendError) {
|
|
1737
|
+
status = err.statusCode;
|
|
1738
|
+
}
|
|
1739
|
+
else if (err instanceof multer_1.default.MulterError) {
|
|
1740
|
+
status = 400;
|
|
1741
|
+
if (err.code === 'LIMIT_FILE_SIZE')
|
|
1742
|
+
msg = `文件超出大小限制(${(live.maxSize / 1024 / 1024).toFixed(0)}MB)`;
|
|
1743
|
+
else if (err.code === 'LIMIT_FILE_COUNT')
|
|
1744
|
+
msg = '一次上传的文件数量超出限制';
|
|
1745
|
+
else if (err.code === 'LIMIT_UNEXPECTED_FILE')
|
|
1746
|
+
msg = '非预期的文件字段';
|
|
1747
|
+
}
|
|
1748
|
+
get_logger_1.logger.error('[localsend]', err);
|
|
1749
|
+
res.status(status).json({ code: 1, msg });
|
|
1750
|
+
});
|
|
1751
|
+
return {
|
|
1752
|
+
stop: () => {
|
|
1753
|
+
// 断开所有事件推送连接
|
|
1754
|
+
for (const client of eventClients) {
|
|
1755
|
+
try {
|
|
1756
|
+
client.end();
|
|
1757
|
+
}
|
|
1758
|
+
catch {
|
|
1759
|
+
// 忽略关闭失败
|
|
1760
|
+
}
|
|
1761
|
+
}
|
|
1762
|
+
eventClients.clear();
|
|
1763
|
+
// 停止目录监听与后台定时任务,否则进程无法退出
|
|
1764
|
+
listCache.stop();
|
|
1765
|
+
trash.stop();
|
|
1766
|
+
shareStore.stop();
|
|
1767
|
+
chunkStore.stop();
|
|
1768
|
+
ticketStore.stop();
|
|
1769
|
+
},
|
|
1770
|
+
};
|
|
1771
|
+
}
|