dsh-m 0.0.2 → 0.1.0

package/lib/core/registry.js

@@ -0,0 +1,165 @@
+/**
+ * registry（DESIGN.md §2）：repo 内手工 curated 的 registry.json。
+ * 分发顺序：源覆盖 → jsDelivr @main → raw @main → TTL 缓存 → 包内快照兜底。
+ */
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { join } from 'node:path';
+import { cacheDir } from './env.js';
+import { fetchJsonLimited } from './httpx.js';
+export const CATEGORIES = ['market', 'tools', 'ui', 'search', 'media', 'other'];
+const REPO = 'iasiv5/dsh-m';
+const DEFAULT_URLS = [
+    { source: 'jsdelivr', url: `https://cdn.jsdelivr.net/gh/${REPO}@main/registry.json` },
+    { source: 'raw', url: `https://raw.githubusercontent.com/${REPO}/main/registry.json` },
+];
+// ---------- 校验 ----------
+const GITHUB_RE = /^[A-Za-z0-9][A-Za-z0-9-]*\/[A-Za-z0-9._-]+$/;
+const HTTPS_URL_RE = /^https:\/\/\S+$/i;
+export function validateRegistry(raw) {
+    const errors = [];
+    if (!raw || typeof raw !== 'object')
+        return { ok: false, errors: ['registry 根必须是对象'], registry: null };
+    const obj = raw;
+    if (obj.version !== 1)
+        errors.push('version 必须为 1');
+    if (!Array.isArray(obj.plugins))
+        return { ok: false, errors: [...errors, 'plugins 必须是数组'], registry: null };
+    const plugins = [];
+    const seen = new Set();
+    obj.plugins.forEach((item, index) => {
+        const where = `plugins[${index}]`;
+        if (!item || typeof item !== 'object') {
+            errors.push(`${where}: 必须是对象`);
+            return;
+        }
+        const e = item;
+        const id = String(e.id || '').trim();
+        if (!id || id.length > 64)
+            return errors.push(`${where}.id 无效`);
+        if (seen.has(id))
+            return errors.push(`${where}.id 重复: ${id}`);
+        seen.add(id);
+        const category = String(e.category || '');
+        if (!CATEGORIES.includes(category))
+            return errors.push(`${where}.category 无效: ${category}`);
+        const source = String(e.source || '');
+        if (source !== 'npm' && source !== 'github')
+            return errors.push(`${where}.source 无效: ${source}`);
+        const entry = {
+            id,
+            name: String(e.name || id).trim().slice(0, 100),
+            description: String(e.description || '').trim().slice(0, 500),
+            category: category,
+            tags: Array.isArray(e.tags) ? e.tags.map((t) => String(t).trim().slice(0, 30)).filter(Boolean).slice(0, 10) : [],
+            source,
+        };
+        if (source === 'npm') {
+            const npm = String(e.npm || '').trim();
+            if (!npm)
+                return errors.push(`${where}.npm 必填（source=npm）`);
+            entry.npm = npm;
+        }
+        if (source === 'github') {
+            const gh = String(e.github || '').trim();
+            if (!GITHUB_RE.test(gh))
+                return errors.push(`${where}.github 必须是 owner/repo（source=github）`);
+            entry.github = gh;
+        }
+        if (e.npm && source !== 'npm')
+            entry.npm = String(e.npm).trim();
+        if (e.github && source !== 'github' && GITHUB_RE.test(String(e.github).trim()))
+            entry.github = String(e.github).trim();
+        for (const key of ['homepage', 'icon']) {
+            const v = e[key];
+            if (v === undefined || v === null || v === '')
+                continue;
+            const s = String(v).trim();
+            if (!HTTPS_URL_RE.test(s))
+                return errors.push(`${where}.${key} 必须是 https URL`);
+            entry[key] = s;
+        }
+        plugins.push(entry);
+    });
+    return { ok: errors.length === 0, errors, registry: errors.length === 0 ? { version: 1, plugins } : null };
+}
+// ---------- 包内快照兜底 ----------
+function bundledSnapshot() {
+    const require = createRequire(import.meta.url);
+    for (const rel of ['../registry.json', '../../registry.json']) {
+        try {
+            const raw = require(rel);
+            const parsed = validateRegistry(raw);
+            if (parsed.registry)
+                return parsed.registry;
+        }
+        catch {
+            /* try next */
+        }
+    }
+    return { version: 1, plugins: [] };
+}
+function cachePath() {
+    return join(cacheDir(), 'registry.json');
+}
+function readCache() {
+    try {
+        const raw = JSON.parse(readFileSync(cachePath(), 'utf8'));
+        if (!raw || typeof raw !== 'object' || !raw.registry || !Array.isArray(raw.registry.plugins))
+            return null;
+        return raw;
+    }
+    catch {
+        return null;
+    }
+}
+function writeCache(file) {
+    try {
+        mkdirSync(cacheDir(), { recursive: true });
+        writeFileSync(cachePath(), JSON.stringify(file, null, 2));
+    }
+    catch {
+        /* 缓存写失败不致命 */
+    }
+}
+function cacheFresh(file, ttlMin) {
+    const t = Date.parse(file.fetchedAt || '');
+    if (!Number.isFinite(t))
+        return false;
+    return Date.now() - t < ttlMin * 60_000;
+}
+// ---------- 加载 ----------
+export async function loadRegistry(cfg = {}, opts = {}) {
+    const errors = [];
+    const timeoutMs = cfg.timeoutMs ?? 20_000;
+    const ttlMin = Math.max(0, cfg.cacheTtlMin ?? 60);
+    const cached = readCache();
+    if (!opts.force && cached && cacheFresh(cached, ttlMin)) {
+        return { registry: cached.registry, source: 'cache', fetchedAt: cached.fetchedAt, errors };
+    }
+    const candidates = [];
+    if (cfg.registryUrl && cfg.registryUrl.trim()) {
+        candidates.push({ source: 'override', url: cfg.registryUrl.trim() });
+    }
+    candidates.push(...DEFAULT_URLS);
+    for (const candidate of candidates) {
+        try {
+            const raw = await fetchJsonLimited(candidate.url, { timeoutMs });
+            const parsed = validateRegistry(raw);
+            if (!parsed.ok || !parsed.registry) {
+                errors.push(`${candidate.source}: registry 校验失败 — ${parsed.errors.slice(0, 3).join('; ')}`);
+                continue;
+            }
+            const fetchedAt = new Date().toISOString();
+            writeCache({ fetchedAt, source: candidate.source, registry: parsed.registry });
+            return { registry: parsed.registry, source: candidate.source, fetchedAt, errors };
+        }
+        catch (err) {
+            const he = err;
+            errors.push(`${candidate.source}: ${he?.status ? `HTTP ${he.status}` : err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    if (cached)
+        return { registry: cached.registry, source: 'cache', fetchedAt: cached.fetchedAt, errors };
+    return { registry: bundledSnapshot(), source: 'bundled', fetchedAt: null, errors };
+}

package/lib/core/restart.js

@@ -0,0 +1,213 @@
+/**
+ * 自重启：移植自 skillhub restart.ts（tag→OIDC 同源的 dsh-web shim 环境已验证）。
+ * 优先 systemd 单元重启（本机 = deepseek-harness.service，dsh-web.service 为转发 shim）；
+ * 无 systemd 时退回 detached helper 等端口释放后换身重拉。
+ * 安全：restart 端点必须通过 trustedRestartRequest（Origin 与 Host 同源）。
+ */
+import { spawn } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { dshArgv, nodeExecutable } from './dsh-cli.js';
+function headerString(raw) {
+    if (raw === undefined)
+        return undefined;
+    const value = Array.isArray(raw) ? raw[0] : raw;
+    const trimmed = String(value || '').trim();
+    return trimmed === '' ? undefined : trimmed.split(',')[0].trim();
+}
+function parseHost(raw) {
+    try {
+        const parsed = new URL(raw.includes('://') ? raw : `http://${raw}`);
+        return { hostname: parsed.hostname.toLowerCase(), port: parsed.port };
+    }
+    catch {
+        return null;
+    }
+}
+function isLoopbackHost(host) {
+    const parsed = parseHost(host);
+    if (parsed === null)
+        return false;
+    return parsed.hostname === '127.0.0.1' || parsed.hostname === 'localhost' || parsed.hostname === '::1';
+}
+function hostsMatch(originHost, candidate) {
+    const a = parseHost(originHost);
+    const b = parseHost(candidate);
+    if (a === null || b === null)
+        return false;
+    if (a.hostname !== b.hostname)
+        return false;
+    if (a.port !== '' && b.port !== '' && a.port !== b.port)
+        return false;
+    return true;
+}
+export function servingPort(request) {
+    const host = headerString(request.headers.host);
+    if (host === undefined || !isLoopbackHost(host))
+        return null;
+    const match = /:(\d{1,5})$/u.exec(host);
+    if (match === null)
+        return null;
+    const port = Number(match[1]);
+    return Number.isInteger(port) && port > 0 && port < 65536 ? port : null;
+}
+export function trustedRestartRequest(request) {
+    const origin = headerString(request.headers.origin);
+    if (origin === undefined)
+        return false;
+    let from;
+    try {
+        const parsed = new URL(origin);
+        if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:')
+            return false;
+        from = parsed.host;
+    }
+    catch {
+        return false;
+    }
+    const host = headerString(request.headers.host);
+    const forwardedHost = headerString(request.headers['x-forwarded-host']);
+    const candidates = [host, forwardedHost].filter((value) => value !== undefined);
+    return candidates.some((candidate) => hostsMatch(from, candidate));
+}
+export function readProcCgroup(readFile = (path, encoding) => readFileSync(path, encoding)) {
+    try {
+        return readFile('/proc/self/cgroup', 'utf8');
+    }
+    catch {
+        return '';
+    }
+}
+export function systemdUnitName(cgroupText) {
+    for (const line of cgroupText.split(/\r?\n/u)) {
+        if (line.trim() === '')
+            continue;
+        const path = line.includes(':') ? line.slice(line.lastIndexOf(':') + 1) : line;
+        const parts = path.split('/').filter(Boolean);
+        for (let i = parts.length - 1; i >= 0; i--) {
+            const part = parts[i];
+            if (!part.endsWith('.service'))
+                continue;
+            if (/^user@\d+\.service$/u.test(part))
+                continue;
+            return part;
+        }
+    }
+    return null;
+}
+export function systemdRestartArgv(opts) {
+    const unit = systemdUnitName(opts.cgroup);
+    if (unit === null)
+        return null;
+    if (opts.cgroup.includes('/user.slice/')) {
+        return { file: 'systemctl', args: ['--user', 'restart', '--no-block', unit] };
+    }
+    if (opts.uid === 0) {
+        return { file: 'systemctl', args: ['restart', '--no-block', unit] };
+    }
+    return { file: 'sudo', args: ['-n', 'systemctl', 'restart', '--no-block', unit] };
+}
+export function restartLaunch() {
+    const launch = dshArgv();
+    return {
+        ...launch,
+        args: [...launch.args, ...process.argv.slice(2)],
+        cwd: launch.cwd ?? process.cwd(),
+    };
+}
+function respawnInvocation(launch, platform = process.platform) {
+    if (platform !== 'win32') {
+        return { file: launch.file, args: launch.args, viaShell: launch.viaShell, detached: true };
+    }
+    const quote = (part) => `'${part.replace(/'/g, "''")}'`;
+    return {
+        file: 'powershell.exe',
+        args: ['-NoProfile', '-WindowStyle', 'Hidden', '-Command',
+            [`& ${quote(launch.file)}`, ...launch.args.map(quote)].join(' ')],
+        viaShell: false,
+        detached: false,
+    };
+}
+function restartHelperSource(spawned, launch, logs, port) {
+    return [
+        "const { spawn } = require('node:child_process')",
+        "const fs = require('node:fs')",
+        "const net = require('node:net')",
+        `const file = ${JSON.stringify(spawned.file)}`,
+        `const args = ${JSON.stringify(spawned.args)}`,
+        `const cwd = ${JSON.stringify(launch.cwd)}`,
+        `const viaShell = ${JSON.stringify(spawned.viaShell)}`,
+        `const detached = ${JSON.stringify(spawned.detached)}`,
+        `const logOut = ${JSON.stringify(logs.out)}`,
+        `const logErr = ${JSON.stringify(logs.err)}`,
+        `const port = ${JSON.stringify(port)}`,
+        'const sleep = (ms) => new Promise(r => setTimeout(r, ms))',
+        "const note = (line) => { try { fs.appendFileSync(logErr, `[dsh-m] ${line}\\n`) } catch {} }",
+        'const listening = () => new Promise((resolve) => {',
+        '  const probe = net.connect({ host: "127.0.0.1", port })',
+        '  const done = (value) => { probe.destroy(); resolve(value) }',
+        '  probe.on("connect", () => done(true))',
+        '  probe.on("error", () => done(false))',
+        '  setTimeout(() => done(false), 500)',
+        '})',
+        'const main = async () => {',
+        '  if (port) {',
+        '    const until = Date.now() + 30000',
+        '    while (Date.now() < until && await listening()) await sleep(250)',
+        '    if (await listening()) note(`port ${port} was still in use after 30s; starting anyway`)',
+        '    await sleep(300)',
+        '  } else {',
+        '    await sleep(1500)',
+        '  }',
+        "  let child",
+        '  try {',
+        '    const out = fs.openSync(logOut, "a")',
+        '    const err = fs.openSync(logErr, "a")',
+        '    child = spawn(file, args, { cwd, detached, stdio: ["ignore", out, err], env: process.env, shell: viaShell })',
+        '    child.on("error", (error) => note(`could not start the replacement: ${error && error.message ? error.message : error}`))',
+        '    child.unref()',
+        '  } catch (error) {',
+        '    note(`could not start the replacement: ${error && error.message ? error.message : error}`)',
+        '    return',
+        '  }',
+        '  if (!port) { await sleep(3000); return }',
+        '  const upBy = Date.now() + 20000',
+        '  while (Date.now() < upBy && !(await listening())) await sleep(500)',
+        '  if (!(await listening())) note(`the replacement did not bind port ${port} within 20s — see the output log beside this one`)',
+        '}',
+        'main()',
+    ].join('\n');
+}
+export function scheduleRestart(port = null, deps = {}) {
+    const pid = deps.pid ?? process.pid;
+    const systemd = systemdRestartArgv({
+        cgroup: deps.cgroup ?? readProcCgroup(),
+        uid: deps.uid ?? (typeof process.getuid === 'function' ? process.getuid() : 1),
+    });
+    if (systemd !== null) {
+        ;
+        (deps.setTimeout ?? setTimeout)(() => {
+            const helper = (deps.spawn ?? spawn)(systemd.file, systemd.args, {
+                detached: true,
+                stdio: 'ignore',
+                env: process.env,
+            });
+            helper.unref();
+        }, 500);
+        return { pid, helperPid: undefined, via: 'systemd' };
+    }
+    const launch = (deps.restartLaunch ?? restartLaunch)();
+    const spawned = respawnInvocation(launch);
+    const stamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+    const logOut = join(tmpdir(), `dshm-restart-${stamp}.out.log`);
+    const logErr = join(tmpdir(), `dshm-restart-${stamp}.err.log`);
+    const helper = (deps.spawn ?? spawn)((deps.nodeExecutable ?? nodeExecutable)(), ['-e', restartHelperSource(spawned, launch, { out: logOut, err: logErr }, port)], {
+        detached: true,
+        stdio: 'ignore',
+        env: process.env,
+    });
+    helper.unref();
+    (deps.setTimeout ?? setTimeout)(() => (deps.kill ?? process.kill)(pid, 'SIGTERM'), 500);
+    return { pid, helperPid: helper.pid, via: 'helper' };
+}

package/lib/core/versions.js

@@ -0,0 +1,47 @@
+/**
+ * 最新版本解析（DESIGN.md §3：版本不写死，运行时实查）。
+ * npm：registry /latest（pnpm 安装本身会按 lock integrity 校验 tarball）。
+ * GitHub：api.github.com 解析 HEAD commit SHA（未认证限额 60 次/小时，自用足够）。
+ */
+import { fetchJsonLimited } from './httpx.js';
+export async function npmLatest(pkg, timeoutMs = 20_000) {
+    // 允许 scoped 包名：@scope/name（isSafePkgName 同款字符集）
+    if (!/^@?[A-Za-z0-9-._~]+(\/[A-Za-z0-9-._~]+)?$/.test(pkg))
+        throw new Error(`无效 npm 包名: ${pkg}`);
+    const data = await fetchJsonLimited(`https://registry.npmjs.org/${encodeURIComponent(pkg)}/latest`, { timeoutMs });
+    const version = typeof data.version === 'string' ? data.version : '';
+    if (!version)
+        throw new Error(`npm 未返回版本: ${pkg}`);
+    return {
+        version,
+        integrity: typeof data.dist?.integrity === 'string' ? data.dist.integrity : undefined,
+        tarball: typeof data.dist?.tarball === 'string' ? data.dist.tarball : undefined,
+    };
+}
+export async function githubHeadSha(repo, timeoutMs = 20_000) {
+    if (!/^[A-Za-z0-9][A-Za-z0-9-]*\/[A-Za-z0-9._-]+$/.test(repo))
+        throw new Error(`无效 GitHub 仓库: ${repo}`);
+    const data = await fetchJsonLimited(`https://api.github.com/repos/${repo}/commits/HEAD`, {
+        timeoutMs,
+        headers: { accept: 'application/vnd.github+json' },
+    });
+    const sha = typeof data.sha === 'string' ? data.sha : '';
+    if (!/^[0-9a-f]{40}$/.test(sha))
+        throw new Error(`GitHub 未返回有效 SHA: ${repo}`);
+    return sha;
+}
+export function isNewerVersion(candidate, current) {
+    const parse = (v) => String(v || '')
+        .replace(/^v/i, '')
+        .split(/[-+.]/)
+        .map((part) => (/^\d+$/.test(part) ? Number(part) : part))
+        .map((n) => (typeof n === 'number' ? n : 0));
+    const a = parse(candidate);
+    const b = parse(current);
+    for (let i = 0; i < Math.max(a.length, b.length); i++) {
+        const diff = (a[i] ?? 0) - (b[i] ?? 0);
+        if (diff !== 0)
+            return diff > 0;
+    }
+    return false;
+}

package/lib/host.js

@@ -0,0 +1,187 @@
+import { createRequire } from 'node:module';
+import Schema from '@deepseek-ai/schemastery';
+import { installFromRegistry, listInstalledWithMeta, listMarket, uninstallPlugin, upgradePlugin, withMutationLock, } from './core/market.js';
+import { bindLoaderHost } from './core/live-plugin.js';
+import { scheduleRestart, servingPort, trustedRestartRequest } from './core/restart.js';
+import { registerTools } from './tools.js';
+const require = createRequire(import.meta.url);
+const pkg = require('../package.json');
+export const name = 'dshm';
+// dshm_* 七个工具（src/tools.ts）
+export const inject = ['tools'];
+export const Config = Schema.object({
+    registryUrl: Schema.string().description('registry 源覆盖（默认 jsDelivr @main）'),
+    timeoutMs: Schema.number().default(20000).description('上游请求超时（毫秒）'),
+    cacheTtlMin: Schema.number().default(60).description('registry 缓存时长（分钟）'),
+});
+export function apply(ctx, config) {
+    const cfg = { ...config };
+    // 卸载前的 live-disable 依赖 loader（skillhub 同款）
+    bindLoaderHost(ctx);
+    // dshm_* 七个 agent 工具 + systemPrompt 注入
+    registerTools(ctx, cfg);
+    // 本地 API：单路由 + method 分发（skillhub 同款）
+    ctx.inject(['webServer'], (c) => {
+        const server = c.webServer;
+        server.register({
+            kind: 'exact',
+            path: '/dshm',
+            handler: (req, res) => {
+                void handleApi(req, res, cfg);
+            },
+        });
+    });
+    // 设置页（GUI 设置卡片的宿主命名空间）
+    ctx.inject(['settings'], (c) => {
+        const settings = c.settings;
+        settings.register('dshm', Config, { base: config });
+    });
+}
+async function handleApi(req, res, cfg) {
+    try {
+        const url = new URL(req.url || '/', 'http://127.0.0.1');
+        const body = req.method === 'POST' ? await readBody(req) : {};
+        const method = String(body.method || url.searchParams.get('method') || 'ping');
+        switch (method) {
+            case 'ping':
+                return sendJson(res, 200, {
+                    ok: true,
+                    plugin: pkg.name,
+                    version: pkg.version,
+                    node: process.version,
+                    boot: `${process.pid}`,
+                });
+            case 'self-check': {
+                try {
+                    const { npmLatest } = await import('./core/versions.js');
+                    const latest = await npmLatest(pkg.name, cfg.timeoutMs ?? 20_000);
+                    const { isNewerVersion } = await import('./core/versions.js');
+                    return sendJson(res, 200, {
+                        ok: true,
+                        current: pkg.version,
+                        latest: latest.version,
+                        outdated: isNewerVersion(latest.version, pkg.version),
+                    });
+                }
+                catch (err) {
+                    return sendJson(res, 200, {
+                        ok: true,
+                        current: pkg.version,
+                        latest: null,
+                        outdated: false,
+                        error: err instanceof Error ? err.message : String(err),
+                    });
+                }
+            }
+            case 'self-upgrade': {
+                const { npmLatest } = await import('./core/versions.js');
+                const latest = await npmLatest(pkg.name, cfg.timeoutMs ?? 20_000);
+                const result = await withMutationLock(async () => {
+                    const { addDshPlugin } = await import('./core/dsh-cli.js');
+                    return addDshPlugin(`${pkg.name}@${latest.version}`);
+                });
+                return sendJson(res, 200, {
+                    ok: true,
+                    pkg: pkg.name,
+                    version: latest.version,
+                    usedAllowAllBuilds: result.usedAllowAllBuilds,
+                    needsRestart: true,
+                });
+            }
+            case 'registry': {
+                const loaded = await loadRegistrySafe(cfg, boolArg(body.force));
+                return sendJson(res, 200, {
+                    ok: true,
+                    plugins: loaded.registry.plugins,
+                    source: loaded.source,
+                    fetchedAt: loaded.fetchedAt,
+                    errors: loaded.errors,
+                });
+            }
+            case 'market': {
+                const result = await listMarket(cfg, { force: boolArg(body.force) });
+                return sendJson(res, 200, { ok: true, ...result });
+            }
+            case 'installed': {
+                const result = await listInstalledWithMeta(cfg);
+                return sendJson(res, 200, { ok: true, ...result });
+            }
+            case 'install': {
+                const id = String(body.id || '').trim();
+                if (!id)
+                    return sendJson(res, 400, { ok: false, error: '缺少 id' });
+                const version = typeof body.version === 'string' ? body.version : undefined;
+                const result = await withMutationLock(() => installFromRegistry(id, cfg, { version }));
+                return sendJson(res, 200, { ok: true, ...result });
+            }
+            case 'uninstall': {
+                const target = String(body.pkg || '').trim();
+                if (!target)
+                    return sendJson(res, 400, { ok: false, error: '缺少 pkg' });
+                const result = await withMutationLock(() => uninstallPlugin(target, cfg));
+                return sendJson(res, 200, { ok: true, ...result });
+            }
+            case 'upgrade': {
+                const target = String(body.pkg || '').trim();
+                if (!target)
+                    return sendJson(res, 400, { ok: false, error: '缺少 pkg' });
+                const result = await withMutationLock(() => upgradePlugin(target, cfg));
+                return sendJson(res, 200, { ok: true, ...result });
+            }
+            case 'restart': {
+                if (!trustedRestartRequest(req)) {
+                    return sendJson(res, 403, { ok: false, error: '拒绝跨源重启请求' });
+                }
+                const result = scheduleRestart(servingPort(req));
+                return sendJson(res, 200, { ok: true, ...result });
+            }
+            default:
+                return sendJson(res, 404, { ok: false, error: `未知 method: ${method}` });
+        }
+    }
+    catch (err) {
+        return sendJson(res, 500, { ok: false, error: err instanceof Error ? err.message : String(err) });
+    }
+}
+async function loadRegistrySafe(cfg, force) {
+    const { loadRegistry } = await import('./core/registry.js');
+    return loadRegistry(cfg, { force });
+}
+function boolArg(v) {
+    return v === true || v === 'true' || v === 1 || v === '1';
+}
+function readBody(req, maxBytes = 1 << 20) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        let size = 0;
+        req.on('data', (c) => {
+            size += c.length;
+            if (size > maxBytes) {
+                reject(new Error('请求体过大'));
+                req.destroy();
+                return;
+            }
+            chunks.push(c);
+        });
+        req.on('end', () => {
+            if (!chunks.length)
+                return resolve({});
+            try {
+                resolve(JSON.parse(Buffer.concat(chunks).toString('utf8')));
+            }
+            catch {
+                resolve({});
+            }
+        });
+        req.on('error', reject);
+    });
+}
+function sendJson(res, status, value) {
+    const body = JSON.stringify(value);
+    res.writeHead(status, {
+        'content-type': 'application/json; charset=utf-8',
+        'content-length': Buffer.byteLength(body),
+        'cache-control': 'no-store',
+    });
+    res.end(body);
+}