448 lines
15 KiB
JavaScript
448 lines
15 KiB
JavaScript
// 本地归档服务：只监听 127.0.0.1，用每次启动生成的令牌限制网页访问。
|
||
//
|
||
// 职责：
|
||
// 1. 监视归档根目录，变动后自动重新生成快照（对应"有新文件自动更新"）
|
||
// 2. 提供检索索引（gzip）
|
||
// 3. 提供读操作：打开文件、在资源管理器中定位
|
||
// 4. 提供安全写操作：新建分类目录、移动、复制、解压；一律先 plan 预览再 apply
|
||
// —— 不提供删除与重命名
|
||
//
|
||
// 所有写操作都校验解析后的绝对路径必须落在归档根目录内，并追加到操作日志。
|
||
|
||
import fs from "node:fs";
|
||
import fsp from "node:fs/promises";
|
||
import http from "node:http";
|
||
import path from "node:path";
|
||
import zlib from "node:zlib";
|
||
import crypto from "node:crypto";
|
||
import { spawn } from "node:child_process";
|
||
import { fileURLToPath, pathToFileURL } from "node:url";
|
||
import { loadConfig, regenerate } from "./archive-source.mjs";
|
||
|
||
const here = path.dirname(fileURLToPath(import.meta.url));
|
||
const projectRoot = path.resolve(here, "..");
|
||
const SEVEN_ZIP = "C:\\Program Files\\7-Zip\\7z.exe";
|
||
|
||
const config = await loadConfig();
|
||
const PORT = config.port ?? 43117;
|
||
const TOKEN = crypto.randomBytes(24).toString("hex");
|
||
const TOKEN_FILE = path.join(projectRoot, ".archive-token");
|
||
await fsp.writeFile(TOKEN_FILE, TOKEN, "utf8");
|
||
|
||
const state = {
|
||
watching: false,
|
||
lastScan: null,
|
||
lastError: null,
|
||
pendingRescan: null,
|
||
};
|
||
|
||
// ---------- 归档根目录围栏 ----------
|
||
// 客户端一律传相对路径（/ 分隔）。解析后必须仍在根目录内，且真实路径也不得越界。
|
||
function resolveInside(relPath) {
|
||
if (typeof relPath !== "string" || relPath.includes("\0"))
|
||
throw httpError(400, "路径不合法");
|
||
const cleaned = relPath.replace(/^[/\\]+/, "").replace(/\//g, path.sep);
|
||
if (!cleaned) throw httpError(400, "路径为空");
|
||
const abs = path.resolve(config.root, cleaned);
|
||
const rel = path.relative(config.root, abs);
|
||
if (rel === "" || rel.startsWith("..") || path.isAbsolute(rel))
|
||
throw httpError(403, "只允许访问归档目录内的路径");
|
||
return abs;
|
||
}
|
||
|
||
function realInside(abs) {
|
||
let real;
|
||
try {
|
||
real = fs.realpathSync(abs);
|
||
} catch {
|
||
return abs; // 还不存在（例如待新建目录）；上一级已校验
|
||
}
|
||
const rel = path.relative(fs.realpathSync(config.root), real);
|
||
if (rel.startsWith("..") || path.isAbsolute(rel))
|
||
throw httpError(403, "解析后的真实路径越出归档目录");
|
||
return real;
|
||
}
|
||
|
||
function httpError(status, message) {
|
||
const error = new Error(message);
|
||
error.status = status;
|
||
return error;
|
||
}
|
||
|
||
// ---------- 统计与日志 ----------
|
||
function statsOf(abs) {
|
||
const out = { exists: false, isDir: false, bytes: 0, files: 0 };
|
||
let stat;
|
||
try {
|
||
stat = fs.lstatSync(abs);
|
||
} catch {
|
||
return out;
|
||
}
|
||
out.exists = true;
|
||
out.isDir = stat.isDirectory();
|
||
if (!out.isDir) {
|
||
out.bytes = stat.size;
|
||
out.files = 1;
|
||
return out;
|
||
}
|
||
const walk = (dir) => {
|
||
let items;
|
||
try {
|
||
items = fs.readdirSync(dir, { withFileTypes: true });
|
||
} catch {
|
||
return;
|
||
}
|
||
for (const item of items) {
|
||
const child = path.join(dir, item.name);
|
||
let s;
|
||
try {
|
||
s = fs.lstatSync(child);
|
||
} catch {
|
||
continue;
|
||
}
|
||
if (s.isDirectory()) walk(child);
|
||
else if (s.isFile()) {
|
||
out.files += 1;
|
||
out.bytes += s.size;
|
||
}
|
||
}
|
||
};
|
||
walk(abs);
|
||
return out;
|
||
}
|
||
|
||
async function writeLog(entry) {
|
||
const logRel = config.logFile ?? "00_索引\\操作日志.jsonl";
|
||
const logAbs = path.join(config.root, logRel);
|
||
await fsp.mkdir(path.dirname(logAbs), { recursive: true });
|
||
await fsp.appendFile(
|
||
logAbs,
|
||
`${JSON.stringify({ at: new Date().toISOString(), ...entry })}\n`,
|
||
"utf8",
|
||
);
|
||
}
|
||
|
||
const sameVolume = (a, b) =>
|
||
path.parse(a).root.toLowerCase() === path.parse(b).root.toLowerCase();
|
||
|
||
// ---------- 操作计划（读操作也能生成计划） ----------
|
||
function buildPlan({ op, from, to, folder }) {
|
||
switch (op) {
|
||
case "mkdir": {
|
||
const abs = resolveInside(folder);
|
||
const exists = fs.existsSync(abs);
|
||
return {
|
||
op,
|
||
from: null,
|
||
to: path.relative(config.root, abs).replace(/\\/g, "/"),
|
||
targetExists: exists,
|
||
blocked: exists ? "目标目录已存在" : null,
|
||
note: exists ? null : "将新建一个分类目录",
|
||
bytes: 0,
|
||
files: 0,
|
||
};
|
||
}
|
||
case "move":
|
||
case "copy": {
|
||
const srcAbs = realInside(resolveInside(from));
|
||
const dstAbs = resolveInside(to);
|
||
const src = statsOf(srcAbs);
|
||
if (!src.exists) return { op, from, to, blocked: "源不存在", bytes: 0, files: 0 };
|
||
const targetExists = fs.existsSync(dstAbs);
|
||
const crossVolume = !sameVolume(srcAbs, dstAbs);
|
||
const blocked =
|
||
op === "move" && crossVolume
|
||
? "跨盘移动不被允许（请改用复制）"
|
||
: targetExists
|
||
? "目标已存在，请换一个名字"
|
||
: null;
|
||
return {
|
||
op,
|
||
from: path.relative(config.root, srcAbs).replace(/\\/g, "/"),
|
||
to: path.relative(config.root, dstAbs).replace(/\\/g, "/"),
|
||
bytes: src.bytes,
|
||
files: src.files,
|
||
isDir: src.isDir,
|
||
targetExists,
|
||
crossVolume,
|
||
blocked,
|
||
note: src.isDir
|
||
? `目录，含 ${src.files} 个文件`
|
||
: `文件，${src.bytes} 字节`,
|
||
};
|
||
}
|
||
case "extract": {
|
||
const srcAbs = realInside(resolveInside(from));
|
||
if (!fs.existsSync(srcAbs)) return { op, from, to, blocked: "压缩包不存在", bytes: 0, files: 0 };
|
||
const dstAbs = resolveInside(to);
|
||
const dst = statsOf(dstAbs);
|
||
const targetExists = dst.exists && dst.files > 0;
|
||
return {
|
||
op,
|
||
from: path.relative(config.root, srcAbs).replace(/\\/g, "/"),
|
||
to: path.relative(config.root, dstAbs).replace(/\\/g, "/"),
|
||
bytes: fs.statSync(srcAbs).size,
|
||
files: 0,
|
||
targetExists,
|
||
blocked: targetExists ? "目标目录已存在且非空" : null,
|
||
note: `解压到 ${path.relative(config.root, dstAbs).replace(/\\/g, "/") || "."}`,
|
||
};
|
||
}
|
||
default:
|
||
throw httpError(400, `不支持的操作：${op}`);
|
||
}
|
||
}
|
||
|
||
async function applyPlan({ op, from, to, folder }) {
|
||
const plan = buildPlan({ op, from, to, folder });
|
||
if (plan.blocked) throw httpError(409, plan.blocked);
|
||
|
||
if (op === "mkdir") {
|
||
const abs = resolveInside(folder);
|
||
await fsp.mkdir(abs, { recursive: true });
|
||
} else if (op === "move") {
|
||
const abs = resolveInside(to);
|
||
await fsp.mkdir(path.dirname(abs), { recursive: true });
|
||
await fsp.rename(resolveInside(from), abs);
|
||
} else if (op === "copy") {
|
||
const abs = resolveInside(to);
|
||
await fsp.mkdir(path.dirname(abs), { recursive: true });
|
||
await fsp.cp(resolveInside(from), abs, { recursive: true, errorOnExist: true });
|
||
} else if (op === "extract") {
|
||
if (!fs.existsSync(SEVEN_ZIP)) throw httpError(500, `找不到 7-Zip：${SEVEN_ZIP}`);
|
||
const abs = resolveInside(to);
|
||
await fsp.mkdir(abs, { recursive: true });
|
||
const code = await new Promise((resolve) => {
|
||
const child = spawn(
|
||
SEVEN_ZIP,
|
||
["x", resolveInside(from), `-o${abs}`, "-y", "-bso0", "-bsp0"],
|
||
{ stdio: "ignore", windowsHide: true },
|
||
);
|
||
child.on("close", resolve);
|
||
child.on("error", () => resolve(-1));
|
||
});
|
||
if (code !== 0) throw httpError(500, `7-Zip 解压失败（退出码 ${code}）`);
|
||
}
|
||
|
||
await writeLog({ op, from: plan.from, to: plan.to, result: "ok" });
|
||
scheduleRescan();
|
||
return plan;
|
||
}
|
||
|
||
// ---------- 读操作：交给系统 ----------
|
||
function reveal(abs) {
|
||
spawn("explorer.exe", [`/select,${abs}`], { stdio: "ignore", windowsHide: false }).unref();
|
||
}
|
||
function openWith(abs) {
|
||
spawn("cmd.exe", ["/c", "start", "", abs], { stdio: "ignore", windowsHide: true }).unref();
|
||
}
|
||
|
||
// ---------- 快照刷新与自动更新 ----------
|
||
let timer = null;
|
||
function scheduleRescan(delay = 2500) {
|
||
clearTimeout(timer);
|
||
timer = setTimeout(async () => {
|
||
try {
|
||
const result = await regenerate({ quiet: true });
|
||
state.lastScan = result.generated;
|
||
state.lastError = null;
|
||
broadcast({ type: "rescan", generated: result.generated, totals: result.totals });
|
||
} catch (error) {
|
||
state.lastError = error.message;
|
||
}
|
||
}, delay);
|
||
}
|
||
|
||
const clients = new Set();
|
||
function broadcast(message) {
|
||
const line = `data: ${JSON.stringify(message)}\n\n`;
|
||
for (const res of clients) {
|
||
try {
|
||
res.write(line);
|
||
} catch {
|
||
clients.delete(res);
|
||
}
|
||
}
|
||
}
|
||
|
||
function startWatcher() {
|
||
try {
|
||
fs.watch(config.root, { recursive: true }, (_event, filename) => {
|
||
if (filename && String(filename).includes("操作日志.jsonl")) return;
|
||
scheduleRescan();
|
||
});
|
||
state.watching = true;
|
||
} catch (error) {
|
||
state.watching = false;
|
||
state.lastError = `无法监视归档目录：${error.message}`;
|
||
}
|
||
}
|
||
|
||
// ---------- HTTP ----------
|
||
const indexAbs = path.join(projectRoot, config.indexFile ?? "public/archive-index.json");
|
||
let indexCache = { mtime: 0, gzip: null, raw: null };
|
||
|
||
function readIndex() {
|
||
const mtime = fs.existsSync(indexAbs) ? fs.statSync(indexAbs).mtimeMs : 0;
|
||
if (indexCache.mtime !== mtime) {
|
||
const raw = mtime ? fs.readFileSync(indexAbs) : Buffer.from("{}");
|
||
indexCache = { mtime, raw, gzip: zlib.gzipSync(raw) };
|
||
}
|
||
return indexCache;
|
||
}
|
||
|
||
function searchIndex(query, limit) {
|
||
const { raw } = readIndex();
|
||
const payload = JSON.parse(raw.toString("utf8"));
|
||
const needle = query.trim().toLowerCase();
|
||
if (!needle) return { total: payload.entries.length, hits: [] };
|
||
const hits = [];
|
||
for (const entry of payload.entries) {
|
||
if (entry[0].toLowerCase().includes(needle)) {
|
||
hits.push(entry);
|
||
if (hits.length >= limit) break;
|
||
}
|
||
}
|
||
return { total: hits.length, hits };
|
||
}
|
||
|
||
async function readBody(req) {
|
||
const chunks = [];
|
||
let size = 0;
|
||
for await (const chunk of req) {
|
||
size += chunk.length;
|
||
if (size > 1_000_000) throw httpError(413, "请求体过大");
|
||
chunks.push(chunk);
|
||
}
|
||
if (!chunks.length) return {};
|
||
try {
|
||
return JSON.parse(Buffer.concat(chunks).toString("utf8"));
|
||
} catch {
|
||
throw httpError(400, "请求体不是合法 JSON");
|
||
}
|
||
}
|
||
|
||
const send = (res, status, body, headers = {}) => {
|
||
const isBuffer = Buffer.isBuffer(body);
|
||
const payload = isBuffer ? body : Buffer.from(JSON.stringify(body));
|
||
res.writeHead(status, {
|
||
"content-type": isBuffer ? "application/octet-stream" : "application/json; charset=utf-8",
|
||
"cache-control": "no-store",
|
||
...headers,
|
||
});
|
||
res.end(payload);
|
||
};
|
||
|
||
const server = http.createServer(async (req, res) => {
|
||
const url = new URL(req.url ?? "/", `http://127.0.0.1:${PORT}`);
|
||
const route = url.pathname;
|
||
|
||
// 事件流不需要令牌以外的额外处理，但同样要求令牌
|
||
if (req.headers["x-archive-token"] !== TOKEN) {
|
||
return send(res, 401, { error: "访问令牌无效" });
|
||
}
|
||
|
||
if (route === "/events") {
|
||
res.writeHead(200, {
|
||
"content-type": "text/event-stream",
|
||
"cache-control": "no-store",
|
||
connection: "keep-alive",
|
||
});
|
||
res.write(": connected\n\n");
|
||
clients.add(res);
|
||
req.on("close", () => clients.delete(res));
|
||
return;
|
||
}
|
||
|
||
try {
|
||
if (route === "/status" && req.method === "GET") {
|
||
const { raw } = readIndex();
|
||
const payload = JSON.parse(raw.toString("utf8"));
|
||
return send(res, 200, {
|
||
root: config.root,
|
||
watching: state.watching,
|
||
lastScan: state.lastScan ?? payload.generated ?? null,
|
||
lastError: state.lastError,
|
||
totals: payload.totals ?? null,
|
||
port: PORT,
|
||
sevenZip: fs.existsSync(SEVEN_ZIP),
|
||
});
|
||
}
|
||
|
||
if (route === "/index" && req.method === "GET") {
|
||
const { raw, gzip } = readIndex();
|
||
if (String(req.headers["accept-encoding"] ?? "").includes("gzip"))
|
||
return send(res, 200, gzip, {
|
||
"content-type": "application/json; charset=utf-8",
|
||
"content-encoding": "gzip",
|
||
});
|
||
return send(res, 200, raw, { "content-type": "application/json; charset=utf-8" });
|
||
}
|
||
|
||
if (route === "/search" && req.method === "GET") {
|
||
const q = url.searchParams.get("q") ?? "";
|
||
const limit = Math.min(Number(url.searchParams.get("limit") ?? 200) || 200, 2000);
|
||
return send(res, 200, searchIndex(q, limit));
|
||
}
|
||
|
||
if (route === "/plan" && req.method === "POST") {
|
||
const body = await readBody(req);
|
||
return send(res, 200, buildPlan(body));
|
||
}
|
||
|
||
if (route === "/apply" && req.method === "POST") {
|
||
const body = await readBody(req);
|
||
if (body.confirm !== true) throw httpError(400, "写操作需要 confirm: true");
|
||
const plan = await applyPlan(body);
|
||
return send(res, 200, { ok: true, plan });
|
||
}
|
||
|
||
if (route === "/reveal" && req.method === "POST") {
|
||
const body = await readBody(req);
|
||
const abs = realInside(resolveInside(body.path));
|
||
if (!fs.existsSync(abs)) throw httpError(404, "路径不存在");
|
||
reveal(abs);
|
||
return send(res, 200, { ok: true, action: "reveal", path: body.path });
|
||
}
|
||
|
||
if (route === "/open" && req.method === "POST") {
|
||
const body = await readBody(req);
|
||
const abs = realInside(resolveInside(body.path));
|
||
if (!fs.existsSync(abs)) throw httpError(404, "路径不存在");
|
||
openWith(abs);
|
||
return send(res, 200, { ok: true, action: "open", path: body.path });
|
||
}
|
||
|
||
if (route === "/refresh" && req.method === "POST") {
|
||
const result = await regenerate({ quiet: true });
|
||
state.lastScan = result.generated;
|
||
state.lastError = null;
|
||
broadcast({ type: "rescan", generated: result.generated, totals: result.totals });
|
||
return send(res, 200, { ok: true, generated: result.generated, totals: result.totals });
|
||
}
|
||
|
||
return send(res, 404, { error: `未知接口：${route}` });
|
||
} catch (error) {
|
||
return send(res, error.status ?? 500, { error: error.message });
|
||
}
|
||
});
|
||
|
||
server.listen(PORT, "127.0.0.1", async () => {
|
||
console.log(`归档服务已启动：http://127.0.0.1:${PORT}`);
|
||
console.log(`归档根目录：${config.root}`);
|
||
console.log(`访问令牌：已写入 ${path.relative(projectRoot, TOKEN_FILE)}`);
|
||
try {
|
||
const result = await regenerate({ quiet: true });
|
||
state.lastScan = result.generated;
|
||
console.log(
|
||
`快照就绪：${result.records.length} 条精选档案，` +
|
||
`${result.totals.files} 个文件 / ${result.totals.dirs} 个目录`,
|
||
);
|
||
} catch (error) {
|
||
state.lastError = error.message;
|
||
console.error(`首次生成快照失败：${error.message}`);
|
||
}
|
||
startWatcher();
|
||
console.log(state.watching ? "已开始监视归档变动（自动更新快照）" : "监视未启用");
|
||
});
|