495 lines
20 KiB
JavaScript
Executable file
495 lines
20 KiB
JavaScript
Executable file
#!/usr/bin/env node
|
||
/**
|
||
* 光湖桥 · 独立参考实现 · guanghu-bridge/v1
|
||
*
|
||
* 定位：光湖桥通信层的独立运行时 + 协议参考实现（P3 最小闭环）。
|
||
* 不依赖任何桌面壳，不依赖第三方包，仅用 Node 内置模块。
|
||
*
|
||
* 分层（对齐 HLP-CURRENT-ARCH-001）：
|
||
* 传输层 TCP + NDJSON 帧（可选 TLS 后续接）
|
||
* 会话层 X25519 密钥交换 + HKDF + AES-256-GCM，中转只见密文
|
||
* 消息层 信封 schema=guanghu.guanghu-bridge-message/v1
|
||
* 事实层 中转节点将信封指纹沉淀 facts/*.ndjson（耐久层入口，Git 可挂）
|
||
*
|
||
* 运行方式：
|
||
* node bridge-node.mjs relay --port 9701 --state-dir <dir>
|
||
* node bridge-node.mjs node --id <节点号> --relay host:port --state-dir <dir>
|
||
* node bridge-node.mjs selftest [--workdir <dir>]
|
||
*/
|
||
|
||
import net from 'node:net';
|
||
import fs from 'node:fs';
|
||
import path from 'node:path';
|
||
import readline from 'node:readline';
|
||
import process from 'node:process';
|
||
import {
|
||
generateKeyPairSync, diffieHellman, hkdfSync, randomBytes,
|
||
createCipheriv, createDecipheriv, createHash, createHmac,
|
||
createPublicKey, createPrivateKey, randomUUID,
|
||
} from 'node:crypto';
|
||
|
||
export const SCHEMA = 'guanghu.guanghu-bridge-message/v1';
|
||
const MAX_LINE = 1024 * 1024;
|
||
|
||
// ────────────────────────── 密钥与加解密 ──────────────────────────
|
||
|
||
function ensureDir(p) { fs.mkdirSync(p, { recursive: true }); return p; }
|
||
|
||
function loadOrCreateIdentity(nodeId, stateDir) {
|
||
const dir = ensureDir(path.join(stateDir, 'identities'));
|
||
const file = path.join(dir, `${nodeId}.key.json`);
|
||
if (fs.existsSync(file)) {
|
||
const j = JSON.parse(fs.readFileSync(file, 'utf8'));
|
||
return {
|
||
nodeId,
|
||
privateKey: createPrivateKey({ key: Buffer.from(j.priv_der_b64, 'base64'), format: 'der', type: 'pkcs8' }),
|
||
pubB64: j.pub_der_b64,
|
||
};
|
||
}
|
||
const { publicKey, privateKey } = generateKeyPairSync('x25519');
|
||
const pubDer = publicKey.export({ type: 'spki', format: 'der' });
|
||
const privDer = privateKey.export({ type: 'pkcs8', format: 'der' });
|
||
fs.writeFileSync(file, JSON.stringify({
|
||
schema: 'guanghu.guanghu-bridge-identity/v1',
|
||
node_id: nodeId,
|
||
pub_der_b64: pubDer.toString('base64'),
|
||
priv_der_b64: privDer.toString('base64'),
|
||
created_at: new Date().toISOString(),
|
||
}, null, 2));
|
||
return { nodeId, privateKey, pubB64: pubDer.toString('base64') };
|
||
}
|
||
|
||
function importPub(b64) {
|
||
return createPublicKey({ key: Buffer.from(b64, 'base64'), format: 'der', type: 'spki' });
|
||
}
|
||
|
||
function sharedIkm(privKey, peerPubB64) {
|
||
return diffieHellman({ privateKey: privKey, publicKey: importPub(peerPubB64) });
|
||
}
|
||
|
||
function deriveKeys(ikm) {
|
||
return {
|
||
msg: Buffer.from(hkdfSync('sha256', ikm, 'guanghu-bridge-v1', 'msg', 32)),
|
||
receipt: Buffer.from(hkdfSync('sha256', ikm, 'guanghu-bridge-v1', 'receipt', 32)),
|
||
};
|
||
}
|
||
|
||
function seal(key, plaintext, aad) {
|
||
const iv = randomBytes(12);
|
||
const c = createCipheriv('aes-256-gcm', key, iv);
|
||
c.setAAD(Buffer.from(aad));
|
||
const ct = Buffer.concat([c.update(plaintext, 'utf8'), c.final()]);
|
||
return { iv_b64: iv.toString('base64'), ct_b64: ct.toString('base64'), tag_b64: c.getAuthTag().toString('base64') };
|
||
}
|
||
|
||
function open(key, payload, aad) {
|
||
const d = createDecipheriv('aes-256-gcm', key, Buffer.from(payload.iv_b64, 'base64'));
|
||
d.setAAD(Buffer.from(aad));
|
||
d.setAuthTag(Buffer.from(payload.tag_b64, 'base64'));
|
||
return Buffer.concat([d.update(Buffer.from(payload.ct_b64, 'base64')), d.final()]).toString('utf8');
|
||
}
|
||
|
||
function signReceipt(key, msgId, from, to, ts) {
|
||
return createHmac('sha256', key).update(`${msgId}|${from}|${to}|${ts}`).digest('base64');
|
||
}
|
||
|
||
// ────────────────────────── NDJSON 帧 ──────────────────────────
|
||
|
||
function attachFraming(socket, onLine) {
|
||
let buf = '';
|
||
socket.on('data', (chunk) => {
|
||
buf += chunk.toString('utf8');
|
||
let idx;
|
||
while ((idx = buf.indexOf('\n')) >= 0) {
|
||
const line = buf.slice(0, idx).trim();
|
||
buf = buf.slice(idx + 1);
|
||
if (!line) continue;
|
||
if (line.length > MAX_LINE) { socket.destroy(); return; }
|
||
try { onLine(JSON.parse(line)); } catch { /* 坏帧丢弃，不断连 */ }
|
||
}
|
||
});
|
||
return (obj) => { if (!socket.destroyed) socket.write(JSON.stringify(obj) + '\n'); };
|
||
}
|
||
|
||
// ────────────────────────── 中转（会合点）──────────────────────────
|
||
|
||
export function startRelay({ port = 0, stateDir, log = () => {} }) {
|
||
ensureDir(stateDir);
|
||
const offlineDir = ensureDir(path.join(stateDir, 'offline'));
|
||
const factsDir = ensureDir(path.join(stateDir, 'facts'));
|
||
const registryFile = path.join(stateDir, 'relay-registry.json');
|
||
const registry = fs.existsSync(registryFile) ? JSON.parse(fs.readFileSync(registryFile, 'utf8')) : {};
|
||
const online = new Map(); // node_id -> send()
|
||
|
||
// 会合点自身身份：用户自有节点的公钥可信任，用于离线信封混合加密
|
||
const relayIdentity = loadOrCreateIdentity('__RELAY__', stateDir);
|
||
|
||
const saveRegistry = () => fs.writeFileSync(registryFile, JSON.stringify(registry, null, 2));
|
||
const factsFile = () => path.join(factsDir, `${new Date().toISOString().slice(0, 10)}.ndjson`);
|
||
|
||
function sinkFact(env) {
|
||
// 耐久事实层入口：只沉淀信封指纹与元数据，不落密文副本
|
||
fs.appendFileSync(factsFile(), JSON.stringify({
|
||
schema: SCHEMA, kind: 'FACT_SINK', ts: new Date().toISOString(),
|
||
msg_id: env.id, from: env.from, to: env.to,
|
||
envelope_sha256: createHash('sha256').update(JSON.stringify(env)).digest('hex'),
|
||
}) + '\n');
|
||
}
|
||
|
||
function reencryptForRecipient(env) {
|
||
// 离线信封原以会合点公钥加密；收件人上线后转成收件人公钥加密再投递，
|
||
// 中转仅在信封生命周期内短暂见到明文
|
||
if (!env.hybrid) return env;
|
||
const entry = registry[env.to];
|
||
if (!entry || !entry.pub) return null;
|
||
try {
|
||
const inKeys = deriveKeys(sharedIkm(relayIdentity.privateKey, env.from_pub));
|
||
const text = open(inKeys.msg, env.payload, env.id);
|
||
const outKeys = deriveKeys(sharedIkm(relayIdentity.privateKey, entry.pub));
|
||
const converted = { ...env, hybrid: false };
|
||
delete converted.from_pub;
|
||
converted.sealed_by = 'RELAY'; // 收件人据此选解密钥
|
||
converted.relay_pub = relayIdentity.pubB64;
|
||
converted.payload = seal(outKeys.msg, text, env.id);
|
||
return converted;
|
||
} catch (e) { log(`relay: 离线信封 ${env.id} 转加密失败（${e.message}）`); return null; }
|
||
}
|
||
|
||
function deliver(env) {
|
||
const send = online.get(env.to);
|
||
if (send) {
|
||
const finalEnv = env.hybrid ? reencryptForRecipient(env) : env;
|
||
if (!finalEnv) {
|
||
fs.appendFileSync(path.join(offlineDir, `${env.to}.ndjson`), JSON.stringify(env) + '\n');
|
||
return false;
|
||
}
|
||
send(finalEnv); log(`relay: 投递 ${env.id} → ${env.to}（在线${env.hybrid ? '·转加密' : ''}）`); return true;
|
||
}
|
||
fs.appendFileSync(path.join(offlineDir, `${env.to}.ndjson`), JSON.stringify(env) + '\n');
|
||
log(`relay: ${env.to} 离线，${env.id} 入离线队列`);
|
||
return false;
|
||
}
|
||
|
||
function flushOffline(nodeId) {
|
||
const file = path.join(offlineDir, `${nodeId}.ndjson`);
|
||
if (!fs.existsSync(file)) return 0;
|
||
const lines = fs.readFileSync(file, 'utf8').split('\n').filter(Boolean);
|
||
fs.unlinkSync(file);
|
||
let n = 0;
|
||
for (const line of lines) {
|
||
try { if (deliver(JSON.parse(line))) n++; } catch { /* 坏行跳过 */ }
|
||
}
|
||
return n;
|
||
}
|
||
|
||
const server = net.createServer((socket) => {
|
||
let peer = null;
|
||
const send = attachFraming(socket, (msg) => {
|
||
if (msg.type === 'HELLO') {
|
||
peer = msg.node_id;
|
||
registry[peer] = { pub: msg.pub, last_seen: new Date().toISOString() };
|
||
saveRegistry();
|
||
online.set(peer, send);
|
||
send({ schema: SCHEMA, type: 'HELLO_ACK', node_id: peer });
|
||
const n = flushOffline(peer);
|
||
log(`relay: 节点 ${peer} 接入${n ? `，补发 ${n} 条离线消息` : ''}`);
|
||
return;
|
||
}
|
||
if (!peer) return;
|
||
if (msg.type === 'SEND' && msg.envelope) {
|
||
const env = msg.envelope;
|
||
sinkFact(env); // 实时是光，事实层是湖底
|
||
deliver(env);
|
||
send({ schema: SCHEMA, type: 'RELAY_ACK', id: env.id });
|
||
return;
|
||
}
|
||
if (msg.type === 'RECEIPT' || msg.type === 'MSG') {
|
||
// RECEIPT 与转发类信封同样按 to 路由
|
||
deliver(msg);
|
||
return;
|
||
}
|
||
if (msg.type === 'GET_PUB') {
|
||
// 收件人未登记时回发会合点公钥（混合加密降级），发送端不阻塞
|
||
const entry = registry[msg.to];
|
||
send({
|
||
schema: SCHEMA, type: 'PUB', node_id: msg.to,
|
||
pub: entry ? entry.pub : relayIdentity.pubB64,
|
||
hybrid: !entry,
|
||
});
|
||
return;
|
||
}
|
||
});
|
||
socket.on('close', () => { if (peer && online.get(peer) === send) online.delete(peer); });
|
||
});
|
||
|
||
return new Promise((resolve) => {
|
||
server.listen(port, '127.0.0.1', () => {
|
||
const actual = server.address().port;
|
||
log(`relay: 会合点启动 127.0.0.1:${actual}`);
|
||
resolve({
|
||
port: actual, stateDir, registry,
|
||
relayPubB64: relayIdentity.pubB64,
|
||
onlineNodes: () => [...online.keys()],
|
||
close: () => new Promise((r) => server.close(r)),
|
||
});
|
||
});
|
||
});
|
||
}
|
||
|
||
// ────────────────────────── 节点 ──────────────────────────
|
||
|
||
export function startNode({ id, relayHost, relayPort, stateDir, log = () => {}, onMessage = () => {} }) {
|
||
ensureDir(stateDir);
|
||
const identity = loadOrCreateIdentity(id, stateDir);
|
||
const receiptsDir = ensureDir(path.join(stateDir, 'receipts', id));
|
||
const pubCache = new Map(); // node_id -> {pub, hybrid}
|
||
const inbox = [];
|
||
let sendFn = null;
|
||
|
||
const socket = net.connect(relayPort, relayHost);
|
||
|
||
async function ensurePeerPub(peerId) {
|
||
// 收到离线补发/陌生对端消息时，缓存里可能只有混合占位公钥，先拉真实公钥
|
||
let entry = pubCache.get(peerId);
|
||
if (entry && !entry.hybrid) return entry;
|
||
sendFn({ schema: SCHEMA, type: 'GET_PUB', to: peerId });
|
||
for (let i = 0; i < 100; i++) {
|
||
await new Promise((r) => setTimeout(r, 20));
|
||
entry = pubCache.get(peerId);
|
||
if (entry && !entry.hybrid) return entry;
|
||
}
|
||
return null;
|
||
}
|
||
|
||
sendFn = attachFraming(socket, (msg) => {
|
||
if (msg.type === 'HELLO_ACK') { log(`node ${id}: 已接入会合点`); return; }
|
||
if (msg.type === 'PUB') { if (msg.pub) pubCache.set(msg.node_id, { pub: msg.pub, hybrid: !!msg.hybrid }); return; }
|
||
if (msg.type === 'MSG') {
|
||
void (async () => {
|
||
const senderEntry = await ensurePeerPub(msg.from);
|
||
// sealed_by=RELAY：离线补发信封由会合点转加密，用会合点公钥解密；
|
||
// 其余用发件人公钥解密
|
||
const decPub = msg.sealed_by === 'RELAY' ? msg.relay_pub : (senderEntry && senderEntry.pub);
|
||
let text = null;
|
||
if (decPub) {
|
||
try {
|
||
const decKeys = deriveKeys(sharedIkm(identity.privateKey, decPub));
|
||
text = open(decKeys.msg, msg.payload, msg.id);
|
||
// 回送达回执：签名键始终用与发件人的共享密钥，保证发件人可验
|
||
if (senderEntry) {
|
||
const rKeys = deriveKeys(sharedIkm(identity.privateKey, senderEntry.pub));
|
||
const ts = new Date().toISOString();
|
||
sendFn({
|
||
schema: SCHEMA, type: 'RECEIPT', id: randomUUID(), msg_id: msg.id,
|
||
from: id, to: msg.from, ts,
|
||
sig: signReceipt(rKeys.receipt, msg.id, id, msg.from, ts),
|
||
});
|
||
}
|
||
} catch (e) { log(`node ${id}: 解密失败 ${msg.id}（${e.message}）`); }
|
||
}
|
||
inbox.push({ msg_id: msg.id, from: msg.from, text, ts: msg.ts });
|
||
onMessage({ msg_id: msg.id, from: msg.from, text });
|
||
})();
|
||
return;
|
||
}
|
||
if (msg.type === 'RECEIPT') {
|
||
// 校验并落回执
|
||
void (async () => {
|
||
const entry = await ensurePeerPub(msg.from);
|
||
let verified = false;
|
||
if (entry) {
|
||
const keys = deriveKeys(sharedIkm(identity.privateKey, entry.pub));
|
||
verified = signReceipt(keys.receipt, msg.msg_id, msg.from, msg.to, msg.ts) === msg.sig;
|
||
}
|
||
fs.writeFileSync(path.join(receiptsDir, `${msg.msg_id}.json`), JSON.stringify({
|
||
schema: 'guanghu.guanghu-bridge-delivery-receipt/v1',
|
||
msg_id: msg.msg_id, from: msg.from, to: msg.to, ts: msg.ts,
|
||
signature_verified: verified,
|
||
}, null, 2));
|
||
log(`node ${id}: 收到送达回执 ${msg.msg_id}（签名${verified ? '验证通过' : '未通过'}）`);
|
||
})();
|
||
return;
|
||
}
|
||
});
|
||
|
||
socket.on('connect', () => {
|
||
sendFn({ schema: SCHEMA, type: 'HELLO', node_id: id, pub: identity.pubB64 });
|
||
});
|
||
|
||
async function resolvePub(to) {
|
||
if (pubCache.has(to)) return pubCache.get(to);
|
||
sendFn({ schema: SCHEMA, type: 'GET_PUB', to });
|
||
for (let i = 0; i < 50 && !pubCache.has(to); i++) await new Promise((r) => setTimeout(r, 20));
|
||
return pubCache.get(to) || null;
|
||
}
|
||
|
||
async function sendText(to, text) {
|
||
const entry = await resolvePub(to);
|
||
if (!entry) throw new Error(`会合点未应答 ${to} 的公钥解析`);
|
||
const keys = deriveKeys(sharedIkm(identity.privateKey, entry.pub));
|
||
const env = {
|
||
schema: SCHEMA, type: 'MSG', id: randomUUID(),
|
||
from: id, to, ts: new Date().toISOString(),
|
||
payload: null,
|
||
// hybrid=true：收件人未登记，信封暂以会合点公钥加密，投递前转加密
|
||
hybrid: entry.hybrid ? true : undefined,
|
||
from_pub: entry.hybrid ? identity.pubB64 : undefined,
|
||
};
|
||
env.payload = seal(keys.msg, text, env.id); // aad 绑定信封 id，防篡改
|
||
sendFn({ schema: SCHEMA, type: 'SEND', envelope: env });
|
||
log(`node ${id}: 发出 ${env.id} → ${to}${entry.hybrid ? '（离线·混合加密）' : ''}`);
|
||
return env.id;
|
||
}
|
||
|
||
return {
|
||
id, inbox,
|
||
sendText,
|
||
receiptsDir,
|
||
close: () => new Promise((r) => { socket.end(); socket.on('close', r); setTimeout(r, 200); }),
|
||
};
|
||
}
|
||
|
||
// ────────────────────────── 自检 ──────────────────────────
|
||
|
||
export async function selftest(workdir) {
|
||
const logs = [];
|
||
const log = (s) => logs.push(s);
|
||
const root = ensureDir(workdir);
|
||
const relay = await startRelay({ port: 0, stateDir: path.join(root, 'relay'), log });
|
||
|
||
const nodeA = await startNode({
|
||
id: 'NODE-A', relayHost: '127.0.0.1', relayPort: relay.port,
|
||
stateDir: path.join(root, 'node-a'), log, onMessage: () => {},
|
||
});
|
||
await new Promise((r) => setTimeout(r, 150));
|
||
|
||
// 场景 1：B 离线时 A 发消息 → 离线队列
|
||
const m1 = await nodeA.sendText('NODE-B', '冰朔，这是离线补发的第一条。');
|
||
await new Promise((r) => setTimeout(r, 150));
|
||
|
||
// 场景 2：B 接入 → 补发 → 解密 → 回执回到 A
|
||
const received = [];
|
||
const nodeB = await startNode({
|
||
id: 'NODE-B', relayHost: '127.0.0.1', relayPort: relay.port,
|
||
stateDir: path.join(root, 'node-b'), log,
|
||
onMessage: (m) => received.push(m),
|
||
});
|
||
await new Promise((r) => setTimeout(r, 400));
|
||
|
||
// 场景 3：双在线直发
|
||
const m2 = await nodeA.sendText('NODE-B', '第二条，双在线直发。');
|
||
await new Promise((r) => setTimeout(r, 400));
|
||
|
||
// 校验
|
||
const facts = fs.readdirSync(path.join(root, 'relay', 'facts')).length > 0;
|
||
const receiptFiles = fs.readdirSync(path.join(root, 'node-a', 'receipts', 'NODE-A'));
|
||
const ok =
|
||
received.length === 2 &&
|
||
received[0].text === '冰朔，这是离线补发的第一条。' &&
|
||
received[1].text === '第二条，双在线直发。' &&
|
||
facts && receiptFiles.length === 2;
|
||
|
||
await nodeA.close(); await nodeB.close(); await relay.close();
|
||
|
||
const report = {
|
||
schema: SCHEMA, kind: 'SELFTEST_REPORT', ts: new Date().toISOString(),
|
||
result: ok ? 'PASS' : 'FAIL',
|
||
checks: {
|
||
offline_queue_and_redelivery: received[0]?.text === '冰朔，这是离线补发的第一条。',
|
||
online_direct_delivery: received[1]?.text === '第二条，双在线直发。',
|
||
e2e_decrypt_ok: received.every((r) => r.text !== null),
|
||
fact_sink_written: facts,
|
||
delivery_receipts_signed: receiptFiles.length === 2,
|
||
},
|
||
msg_ids: [m1, m2],
|
||
};
|
||
fs.writeFileSync(path.join(root, 'SELFTEST-REPORT.json'), JSON.stringify(report, null, 2));
|
||
return report;
|
||
}
|
||
|
||
// ────────────────────────── stdio 桥接 ──────────────────────────
|
||
|
||
function socketStdioBridge(node, emit) {
|
||
// 回执事件：监听回执目录新增文件（简化：由 onMessage 之外补一层轮询不优雅，
|
||
// 改为包一层：直接读 node 内部不可行，用定时器扫描回执目录）
|
||
const seen = new Set();
|
||
const scan = () => {
|
||
try {
|
||
for (const f of fs.readdirSync(node.receiptsDir)) {
|
||
if (seen.has(f)) continue;
|
||
seen.add(f);
|
||
try {
|
||
const r = JSON.parse(fs.readFileSync(path.join(node.receiptsDir, f), 'utf8'));
|
||
emit({ event: 'receipt', msg_id: r.msg_id, from: r.from, verified: r.signature_verified });
|
||
} catch { /* 半写入文件下轮再读 */ }
|
||
}
|
||
} catch { /* 目录尚未建立 */ }
|
||
};
|
||
const timer = setInterval(scan, 300);
|
||
const rl = readline.createInterface({ input: process.stdin });
|
||
rl.on('line', async (line) => {
|
||
let cmd;
|
||
try { cmd = JSON.parse(line); } catch { return; }
|
||
if (cmd.cmd === 'send' && cmd.to && typeof cmd.text === 'string') {
|
||
try { const msgId = await node.sendText(cmd.to, cmd.text); emit({ event: 'sent', msg_id: msgId, to: cmd.to }); }
|
||
catch (e) { emit({ event: 'error', message: e.message }); }
|
||
} else if (cmd.cmd === 'quit') {
|
||
clearInterval(timer); process.exit(0);
|
||
}
|
||
});
|
||
rl.on('close', () => { clearInterval(timer); process.exit(0); });
|
||
emit({ event: 'connected', node_id: node.id });
|
||
}
|
||
|
||
// ────────────────────────── CLI ──────────────────────────
|
||
|
||
function parseArgs(argv) {
|
||
const args = {};
|
||
for (let i = 0; i < argv.length; i++) {
|
||
if (!argv[i].startsWith('--')) continue;
|
||
const key = argv[i].slice(2);
|
||
if (i + 1 < argv.length && !argv[i + 1].startsWith('--')) { args[key] = argv[i + 1]; i++; }
|
||
else args[key] = true; // 无值开关（如 --stdio）
|
||
}
|
||
return args;
|
||
}
|
||
|
||
const [mode, ...rest] = process.argv.slice(2);
|
||
if (mode === 'relay') {
|
||
const a = parseArgs(rest);
|
||
startRelay({ port: Number(a.port || 9701), stateDir: a['state-dir'] || './bridge-state/relay', log: console.log });
|
||
} else if (mode === 'node') {
|
||
const a = parseArgs(rest);
|
||
const [host, port] = (a.relay || '127.0.0.1:9701').split(':');
|
||
const stdio = process.argv.includes('--stdio');
|
||
const emit = (obj) => { if (stdio) process.stdout.write(JSON.stringify(obj) + '\n'); };
|
||
const node = startNode({
|
||
id: a.id, relayHost: host, relayPort: Number(port),
|
||
stateDir: a['state-dir'] || `./bridge-state/${a.id}`,
|
||
log: stdio ? ((s) => console.error(s)) : console.log,
|
||
onMessage: (m) => {
|
||
if (stdio) emit({ event: 'message', msg_id: m.msg_id, from: m.from, text: m.text });
|
||
else console.log(`〔收到 ${m.from}〕${m.text}`);
|
||
},
|
||
});
|
||
if (stdio) {
|
||
// stdio JSON 模式：供 Electron/Tauri 壳以子进程集成（日志走 stderr）
|
||
socketStdioBridge(node, emit);
|
||
} else {
|
||
const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
|
||
rl.on('line', async (line) => {
|
||
const mm = line.match(/^send\s+(\S+)\s+(.+)$/);
|
||
if (mm) { try { await node.sendText(mm[1], mm[2]); } catch (e) { console.error(`发送失败：${e.message}`); } }
|
||
else if (line.trim() === 'quit') process.exit(0);
|
||
else console.log('用法：send <对端节点号> <文本>');
|
||
});
|
||
rl.on('close', () => process.exit(0)); // stdin 结束即退出，不挂死
|
||
}
|
||
} else if (mode === 'selftest') {
|
||
const a = parseArgs(rest);
|
||
const report = await selftest(a.workdir || './bridge-selftest');
|
||
console.log(JSON.stringify(report, null, 2));
|
||
process.exit(report.result === 'PASS' ? 0 : 1);
|
||
} else if (mode) {
|
||
console.log('用法：bridge-node.mjs relay|node|selftest');
|
||
}
|