mn-ws 0.1.0 → 0.2.0

package/lib/protocol.js

@@ -1,208 +0,0 @@
-'use strict';
-
-/**
- * 通道协议：mn-ws server 半 ⇄ client 半 之间的 WebSocket 帧格式。
- *
- * 帧是 JSON 文本。**请求类帧带 id 用于配对** —— 一条 WS 连接上同时跑多个
- * HTTP 请求，响应按 id 归位（见 §多路复用）。
- *
- * 这套协议刻意做成**零语义**的：帧里装的就是「一次 HTTP 请求」与
- * 「一次 HTTP 响应」，server 半原样转发、client 半原样还原。
- * 任何业务语义（nx 的 action、鉴权规则）都不进协议层。
- */
-
-const PROTOCOL_VERSION = 1;
-
-/** 帧类型 */
-const FRAME = {
-  // server → client
-  WELCOME: 'welcome',
-  REGISTERED: 'registered',
-  REQUEST: 'request',
-  ABORT: 'abort',
-  PING: 'ping',
-  SHUTDOWN: 'shutdown',
-  ERROR: 'error',
-  // client → server
-  REGISTER: 'register',
-  RESPONSE: 'response',
-  CHUNK: 'chunk',
-  PONG: 'pong',
-};
-
-/**
- * 不能跨代理转发的头（hop-by-hop）。
- *
- * 这些头描述的是**某一次连接**的属性，转发到下一跳会出错或无意义：
- *   · Connection: keep-alive  —— 新连接会自己协商
- *   · Transfer-Encoding: chunked —— body 已经被完整读成 buffer，重新算长度
- *   · Upgrade / Proxy-*        —— 代理自己的协商，不该替下游决定
- */const HOP_BY_HOP_HEADERS = new Set([
-  'connection',
-  'keep-alive',
-  'proxy-authenticate',
-  'proxy-authorization',
-  'proxy-connection',
-  'te',
-  'trailer',
-  'transfer-encoding',
-  'upgrade',
-]);
-
-/**
- * 请求头里必须**剥离**的头：
- *   · hop-by-hop —— 描述的是某一次连接，不该跨代理
- *   · Origin     —— nx-kv 的跨站防护只放行本机来源，透传浏览器 Origin 会 403
- *   · X-Mn-Ws-Token —— **mn-ws 自己的 L1 凭据**，属于桥接层内部事务，
- *     泄给目标服务等于把门禁令牌交出去
- */
-const STRIP_REQUEST_HEADERS = new Set([
-  ...HOP_BY_HOP_HEADERS,
-  'origin',
-  'x-mn-ws-token',
-]);
-
-/**
- * 响应头里不能转发的头。
- *
- * `content-length` 会在 client half 重新按实际 body 长度计算；
- * `content-encoding` 由 client half 的 http 客户端处理，body 到手时已解码。
- */
-const STRIP_RESPONSE_HEADERS = new Set([...HOP_BY_HOP_HEADERS, 'content-length']);
-
-/** 请求体上限（字节）。与 nx-kv 的 24MB 对齐；base64 后约 32MB。 */
-const MAX_BODY_BYTES = 24 * 1024 * 1024;
-
-/** 单个 HTTP 请求在 server 半的最长等待时间（毫秒）。 */
-const DEFAULT_REQUEST_TIMEOUT_MS = 30_000;
-
-/** 帧编码：把一个对象序列化成 WS 文本帧。 */
-function encodeFrame(obj) {
-  return JSON.stringify(obj);
-}
-
-/**
- * 帧解码。返回 null 表示「这不是一帧合法的协议消息」——
- * 调用方应当忽略并计数，而不是把解析异常抛给连接层。
- */
-function decodeFrame(raw) {
-  if (raw === null || raw === undefined) return null;
-  let text;
-  if (typeof raw === 'string') text = raw;
-  else if (Buffer.isBuffer(raw)) text = raw.toString('utf8');
-  else if (Array.isArray(raw)) text = Buffer.concat(raw).toString('utf8');
-  else return null;
-
-  let obj;
-  try {
-    obj = JSON.parse(text);
-  } catch {
-    return null;
-  }
-  if (!obj || typeof obj !== 'object' || typeof obj.type !== 'string') return null;
-  return obj;
-}
-
-/**
- * 生成一个跨连接唯一的请求 id。
- *
- * server 半的 pending 表是**全局**的（不按连接分表），所以 id 必须全局唯一：
- * 只带连接内计数的话，两条连接上的 "1" 会撞车，响应会被配到错误的请求上。
- */
-let _seq = 0;
-function nextRequestId(prefix = 'r') {
-  _seq = (_seq + 1) % 0xffffff;
-  const rand = Math.random().toString(36).slice(2, 8);
-  return `${prefix}-${Date.now().toString(36)}-${_seq.toString(36)}-${rand}`;
-}
-
-/** 头对象规范化：键统一小写，值统一成数组。 */
-function normalizeHeaders(headers) {
-  const out = {};
-  if (!headers || typeof headers !== 'object') return out;
-  for (const [k, v] of Object.entries(headers)) {
-    const key = String(k).toLowerCase();
-    if (v === undefined || v === null) continue;
-    out[key] = Array.isArray(v) ? v.map((x) => String(x)) : [String(v)];
-  }
-  return out;
-}
-
-/** 取头的第一个值（大小写不敏感）。 */
-function headerValue(headers, name) {
-  if (!headers) return undefined;
-  const key = String(name).toLowerCase();
-  const v = headers[key];
-  if (!v) return undefined;
-  return Array.isArray(v) ? v[0] : v;
-}
-
-/** 剔除不该转发的请求头。 */
-function stripRequestHeaders(headers) {
-  const out = {};
-  for (const [k, v] of Object.entries(headers || {})) {
-    if (STRIP_REQUEST_HEADERS.has(k)) continue;
-    out[k] = v;
-  }
-  return out;
-}
-
-/** 剔除不该转发的响应头。 */
-function stripResponseHeaders(headers) {
-  const out = {};
-  for (const [k, v] of Object.entries(headers || {})) {
-    if (STRIP_RESPONSE_HEADERS.has(k)) continue;
-    out[k] = v;
-  }
-  return out;
-}
-
-/**
- * 把协议层的头（值统一是数组）压平成 Node http 能吃的形状。
- *
- * ## 为什么需要这一步
- *
- * 协议层把头的值统一存成数组，是为了**保住 set-cookie 这类多值头**
- * （一个响应里可以有几十条 Set-Cookie，用 string 就只剩最后一条）。
- * 但 Node 的 `http.request({headers})` 与 `res.writeHead(status, headers)`
- * 要求**除 set-cookie 外全是字符串** —— 直接把数组塞进去会抛
- * `options.headers.host property must be of type string. Received an instance of Array`。
- *
- * @param {object} headers  规范化后的头
- * @param {string[]} [arrayAllowed] 允许保留数组的键（响应侧用 set-cookie）
- */
-function flattenHeaders(headers, arrayAllowed = []) {
-  const out = {};
-  for (const [k, v] of Object.entries(headers || {})) {
-    if (v === undefined || v === null) continue;
-    if (Array.isArray(v)) {
-      if (arrayAllowed.includes(k)) {
-        if (v.length) out[k] = v.map((x) => String(x));
-        continue;
-      }
-      if (!v.length) continue;
-      out[k] = String(v[0]);
-      continue;
-    }
-    out[k] = String(v);
-  }
-  return out;
-}
-
-module.exports = {
-  PROTOCOL_VERSION,
-  FRAME,
-  HOP_BY_HOP_HEADERS,
-  STRIP_REQUEST_HEADERS,
-  STRIP_RESPONSE_HEADERS,
-  MAX_BODY_BYTES,
-  DEFAULT_REQUEST_TIMEOUT_MS,
-  encodeFrame,
-  decodeFrame,
-  nextRequestId,
-  normalizeHeaders,
-  headerValue,
-  stripRequestHeaders,
-  stripResponseHeaders,
-  flattenHeaders,
-};

package/lib/store.js

@@ -1,66 +0,0 @@
-'use strict';
-
-/**
- * 审计落盘：每次经桥的请求记一行 JSONL。
- *
- * 为什么必须落盘：mn-ws server 是**新的公网暴露面**，它能代理到本机的
- * 十几个服务。出事时「谁在什么时候调了哪个 app 的哪个路径」必须查得到，
- * 否则就是一笔糊涂账。
- *
- * 与 mn-rt 的 client/lib/store.js 同款：JSONL 追加，尾部读。
- */
-
-const fs = require('node:fs');
-const path = require('node:path');
-
-class Store {
-  constructor({ dir = null, name = 'requests.jsonl', maxTail = 200 } = {}) {
-    this.dir = dir;
-    this.file = dir ? path.join(dir, name) : null;
-    this.maxTail = maxTail;
-    this._tail = [];
-    if (this.file) {
-      try {
-        fs.mkdirSync(dir, { recursive: true });
-        this._tail = readTail(this.file, this.maxTail);
-      } catch { /* ignore */ }
-    }
-  }
-
-  /** 追加一条记录。 */
-  append(record) {
-    const row = { ts: Date.now(), ...record };
-    this._tail.push(row);
-    if (this._tail.length > this.maxTail) this._tail.shift();
-    if (this.file) {
-      try {
-        fs.appendFileSync(this.file, `${JSON.stringify(row)}\n`);
-      } catch { /* 落盘失败不阻断主流程 */ }
-    }
-    return row;
-  }
-
-  /** 最近若干条（内存里已有一份，进程起来就能读）。 */
-  tail(n = 50) {
-    const k = Math.max(0, this._tail.length - n);
-    return this._tail.slice(k);
-  }
-
-  stats() {
-    return { count: this._tail.length, file: this.file };
-  }
-}
-
-function readTail(file, max) {
-  try {
-    const text = fs.readFileSync(file, 'utf8');
-    const lines = text.split('\n').filter(Boolean);
-    return lines.slice(-max).map((l) => {
-      try { return JSON.parse(l); } catch { return { raw: l }; }
-    });
-  } catch {
-    return [];
-  }
-}
-
-module.exports = { Store };

package/server/auth.js

@@ -1,274 +0,0 @@
-'use strict';
-
-/**
- * mn-ws server 侧的认证：统一登录的公开参数 + 设备令牌的签发与校验。
- *
- * 与 mn-rt 的 server/src/auth.js 同构，但**没有 sessionKey**：
- * mn-ws 桥接的是 HTTP 请求，不是加密信封流，桥接层不需要「会话密钥」概念。
- *
- * 两类凭据：
- *   · 认证中心 access_token —— 短命，登录当场换设备令牌用完即弃，不落盘。
- *   · mn-ws 设备令牌（HS256 JWT）—— 长命，落盘，由本服务签发与吊销。
- */
-
-const crypto = require('crypto');
-const fs = require('node:fs');
-const path = require('node:path');
-const http = require('node:http');
-
-/** 设备令牌有效期（秒）。默认 90 天 —— 桥接是公网暴露面，令牌不宜过长。 */
-const DEVICE_TOKEN_TTL_SEC = 90 * 24 * 3600;
-
-function b64url(buf) {
-  return Buffer.from(buf).toString('base64')
-    .replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
-}
-
-function b64urlJson(obj) {
-  return b64url(Buffer.from(JSON.stringify(obj), 'utf8'));
-}
-
-function fromB64url(s) {
-  const pad = '='.repeat((4 - (s.length % 4)) % 4);
-  return Buffer.from(s.replace(/-/g, '+').replace(/_/g, '/') + pad, 'base64');
-}
-
-class AuthHub {
-  constructor(opts = {}) {
-    this.enabled = opts.enabled === true;
-    this.issuer = opts.issuer || '';
-    this.clientId = opts.clientId || '';
-    this.redirectUri = opts.redirectUri || '';
-    this.scopes = opts.scopes || ['openid', 'profile', 'email'];
-    this.jwtSecret = opts.jwtSecret || '';
-    this.httpTimeoutMs = opts.httpTimeoutMs || 10_000;
-    this.dataDir = opts.dataDir || null;
-
-    /** 发现文档缓存。只有成功才固化——失败若被记住，容器编排下
-     *  "本服务先于认证中心启动" 会让统一登录永久不可用直到重启。 */
-    this._endpoints = null;
-
-    /** clientId -> {userId, deviceName, registeredAt, lastSeenAt} */
-    this.devices = new Map();
-    /** jti -> 过期时间戳（吊销名单） */
-    this.revoked = new Map();
-    this._loadDevices();
-  }
-
-  // ==================== 配置与发现 ====================
-
-  /** 下发给客户端的公开参数。**绝不含任何 secret**。 */
-  publicConfig() {
-    const e = this._endpoints;
-    return {
-      enabled: this.enabled,
-      issuer: this.issuer,
-      clientId: this.clientId,
-      redirectUri: this.redirectUri,
-      scopes: this.scopes,
-      authorizationEndpoint: e ? e.authorization_endpoint : `${this.issuer}/oauth2/auth`,
-      tokenEndpoint: e ? e.token_endpoint : `${this.issuer}/oauth2/token`,
-      idpAvailable: !!e,
-      ...(e ? {} : { idpError: this._discoverError || '未拉取到发现文档' }),
-    };
-  }
-
-  async discover() {
-    if (this._endpoints) return this._endpoints;
-    if (!this.enabled) throw Object.assign(new Error('统一登录未启用'), { code: 'disabled' });
-    const url = `${this.issuer.replace(/\/+$/, '')}/.well-known/openid-configuration`;
-    const doc = await this._fetchJson(url, { method: 'GET' });
-    if (!doc || !doc.token_endpoint) {
-      throw Object.assign(new Error('发现文档不完整'), { code: 'bad_discovery' });
-    }
-    this._endpoints = doc;
-    return doc;
-  }
-
-  async _fetchJson(urlStr, { method = 'GET', headers = {}, body = null } = {}) {
-    return new Promise((resolve, reject) => {
-      let u;
-      try { u = new URL(urlStr); } catch { reject(new Error(`非法地址: ${urlStr}`)); return; }
-      const payload = body === null ? '' : (typeof body === 'string' ? body : JSON.stringify(body));
-      const req = http.request({
-        method,
-        hostname: u.hostname,
-        port: u.port || (u.protocol === 'https:' ? 443 : 80),
-        path: u.pathname + u.search,
-        headers: {
-          ...(payload ? { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(payload) } : {}),
-          ...headers,
-        },
-        timeout: this.httpTimeoutMs,
-      }, (res) => {
-        let raw = '';
-        res.on('data', (c) => { raw += c; });
-        res.on('end', () => {
-          let json = null;
-          try { json = JSON.parse(raw); } catch { /* 非 JSON 就当原文 */ }
-          resolve(json || raw);
-        });
-      });
-      req.on('timeout', () => { req.destroy(new Error('请求超时')); });
-      req.on('error', reject);
-      if (payload) req.write(payload);
-      req.end();
-    });
-  }
-
-  // ==================== 身份 ====================
-
-  /**
-   * 校验一枚**认证中心**的 access_token，返回身份。
-   *
-   * 与 mn-rt 的分工一致：exchange 是"我有 code，服务器你帮我换"，
-   * verifyBearer 是"我有 token，服务器你帮我确认是谁"。两条路最终都收敛到
-   * 同一个结论——认证中心自己断言的 sub，所以属主判定只有一份实现。
-   */
-  async verifyBearer(accessToken) {
-    if (!accessToken) throw Object.assign(new Error('缺少 access_token'), { code: 'bad_request' });
-    const doc = await this.discover();
-    const ui = await this._fetchJson(doc.userinfo_endpoint || `${this.issuer}/oauth2/userinfo`, {
-      headers: { Authorization: `Bearer ${accessToken}` },
-    });
-    if (!ui || ui.error) {
-      throw Object.assign(new Error(`令牌无效: ${ui && ui.error ? ui.error : '无 sub'}`),
-        { code: (ui && ui.error) || 'invalid_token' });
-    }
-    if (!ui.sub) throw Object.assign(new Error('userinfo 未返回 sub'), { code: 'no_sub' });
-    return {
-      userId: String(ui.sub),
-      sub: String(ui.sub),
-      email: ui.email || '',
-      name: ui.name || '',
-      preferredUsername: ui.preferred_username || '',
-    };
-  }
-
-  // ==================== 设备令牌 ====================
-
-  /** 签发设备令牌。HS256 JWT，payload 带 userId 与 clientId。 */
-  issueDeviceToken({ userId, clientId, deviceName }) {
-    if (!this.jwtSecret) {
-      throw Object.assign(new Error('未配置 MN_WS_JWT_SECRET'), { code: 'no_secret' });
-    }
-    const now = Math.floor(Date.now() / 1000);
-    const header = { alg: 'HS256', typ: 'JWT' };
-    const payload = {
-      sub: userId,
-      cid: clientId,
-      dn: deviceName || '',
-      iat: now,
-      exp: now + DEVICE_TOKEN_TTL_SEC,
-      // jti 让单枚令牌可被单独吊销
-      jti: crypto.randomBytes(9).toString('hex'),
-    };
-    const head = b64urlJson(header);
-    const body = b64urlJson(payload);
-    const sig = b64url(crypto.createHmac('sha256', this.jwtSecret).update(`${head}.${body}`).digest());
-    return {
-      token: `${head}.${body}.${sig}`,
-      expiresAt: (now + DEVICE_TOKEN_TTL_SEC) * 1000,
-      jti: payload.jti,
-    };
-  }
-
-  /** 校验设备令牌。返回 payload 或 null。 */
-  verifyDeviceToken(token) {
-    if (!this.jwtSecret || !token || typeof token !== 'string') return null;
-    const parts = token.split('.');
-    if (parts.length !== 3) return null;
-    const [head, body, sig] = parts;
-    const want = b64url(crypto.createHmac('sha256', this.jwtSecret).update(`${head}.${body}`).digest());
-    // 常量时间比较：这里比的是"能不能冒充某个用户的一台桥"
-    const a = Buffer.from(sig);
-    const b = Buffer.from(want);
-    if (a.length !== b.length || !crypto.timingSafeEqual(a, b)) return null;
-    let payload;
-    try { payload = JSON.parse(fromB64url(body).toString('utf8')); } catch { return null; }
-    if (!payload || !payload.sub) return null;
-    if (typeof payload.exp !== 'number' || Math.floor(Date.now() / 1000) >= payload.exp) return null;
-    if (this._isRevoked(payload.jti)) return null;
-    return payload;
-  }
-
-  /** 吊销某枚令牌。名单落盘 —— 否则重启即"全部恢复"，而吊销往往正是因为设备丢了。 */
-  revoke(jti) {
-    if (!jti) return;
-    this.revoked.set(jti, Date.now() + DEVICE_TOKEN_TTL_SEC * 1000);
-    this._saveDevices();
-  }
-
-  _isRevoked(jti) {
-    if (!this.revoked || !jti) return false;
-    const until = this.revoked.get(jti);
-    if (!until) return false;
-    if (until < Date.now()) { this.revoked.delete(jti); return false; }
-    return true;
-  }
-
-  // ==================== 设备登记 ====================
-
-  /** 登记一台桥（client half）：clientId → 属主。永久一对一。 */
-  registerDevice({ clientId, userId, deviceName }) {
-    if (!clientId) throw Object.assign(new Error('缺少 clientId'), { code: 'bad_request' });
-    const existing = this.devices.get(clientId);
-    if (existing && existing.userId !== userId) {
-      throw Object.assign(new Error('该标识已属于别的账号'), { code: 'device_owned_by_other' });
-    }
-    const rec = {
-      userId,
-      clientId,
-      deviceName: deviceName || (existing && existing.deviceName) || '',
-      registeredAt: existing ? existing.registeredAt : new Date().toISOString(),
-      lastSeenAt: new Date().toISOString(),
-    };
-    this.devices.set(clientId, rec);
-    this._saveDevices();
-    return rec;
-  }
-
-  getDevice(clientId) {
-    return this.devices.get(clientId) || null;
-  }
-
-  devicesOf(userId) {
-    return [...this.devices.values()].filter((d) => d.userId === userId);
-  }
-
-  // ==================== 落盘 ====================
-
-  _devicesFile() {
-    return this.dataDir ? path.join(this.dataDir, 'devices.json') : null;
-  }
-
-  _loadDevices() {
-    const f = this._devicesFile();
-    if (!f) return;
-    try {
-      if (!fs.existsSync(f)) return;
-      const raw = JSON.parse(fs.readFileSync(f, 'utf8'));
-      this.devices = new Map(Object.entries(raw.devices || {}));
-      this.revoked = new Map(Object.entries(raw.revoked || {}));
-    } catch {
-      this.devices = new Map();
-      this.revoked = new Map();
-    }
-  }
-
-  _saveDevices() {
-    const f = this._devicesFile();
-    if (!f) return;
-    try {
-      fs.mkdirSync(path.dirname(f), { recursive: true });
-      const tmp = `${f}.${process.pid}.tmp`;
-      fs.writeFileSync(tmp, JSON.stringify({
-        devices: Object.fromEntries(this.devices),
-        revoked: Object.fromEntries(this.revoked),
-      }, null, 2), { mode: 0o600 });
-      fs.renameSync(tmp, f);
-    } catch { /* 落盘失败不阻断主流程 */ }
-  }
-}
-
-module.exports = { AuthHub, DEVICE_TOKEN_TTL_SEC, b64url, fromB64url };