mn-ws 0.1.0 → 0.2.0

package/lib/apps.js

@@ -1,237 +0,0 @@
-'use strict';
-
-/**
- * 可桥接应用（app）表与探测。
- *
- * ## 为什么要有「应用标识」
- *
- * 一台机器上跑着十几个 nx 服务（nx-kv / nx-rh / nx-sk …），每个占一个端口。
- * 桥接要替它们**共用同一条对外的 HTTP 入口**，就必须能区分「这个请求该去
- * 哪个本地端口」——那就是**应用标识（app）**。
- *
- * ## 标识怎么带
- *
- * 两种都支持，**路径前缀优先**：
- *   ① `POST /nx-kv/api/todo/add`      → app=nx-kv, path=/api/todo/add
- *   ② `POST /api/todo/add` + 头 `X-Nx-App: nx-kv` → app=nx-kv, path=/api/todo/add
- *
- * 路径优先的理由：客户端零改造（curl 直接打）、自定义头不会被中间反代剥掉、
- * 且一个请求只可能对应一个 app（没有「路径说 A、头说 B」的歧义）。
- *
- * 两者都缺 → app_required；两者冲突 → app_conflict。
- * **冲突时报错而不是猜**：猜错等于把请求打到别人的服务上。
- */
-
-const net = require('node:net');
-
-/** 请求头：应用标识的备用载体。 */
-const APP_HEADER = 'x-nx-app';
-
-/**
- * 已知 nx 服务（2026-11-12 实测各仓 core/paths.js 的 DEFAULT_PORT）。
- *
- * **这不是白名单** —— 它只是「本机可能有什么」的提示与兜底默认值。
- * 真正能不能桥，由 client half 的配置（--apps / 配置文件）决定：
- * 端口探测只用来显示状态，**绝不因为「扫到端口在监听」就自动开桥**。
- */
-const KNOWN_APPS = {
-  'nx-rh': { title: '仓库与 Skill 中枢', port: 7800 },
-  'nx-rp': { title: '外部上下文', port: 7820 },
-  'nx-sk': { title: '个人资源与密钥', port: 7866 },
-  'nx-ft': { title: '前端资源管理', port: 7869 },
-  'nx-kv': { title: 'KV 清单中枢', port: 7877 },
-  'nx-nx': { title: '项目生成器', port: 7880 },
-  'nx-kn': { title: 'Obsidian 知识库', port: 7881 },
-  'nx-ditto': { title: 'ditto', port: 7883 },
-  'nx-pg': { title: '画布工作台', port: 7888 },
-  'nx-pn': { title: 'pn', port: 4561 },
-};
-
-/** app 名的合法形态：小写字母开头，只含小写字母/数字/连字符。 */
-const APP_NAME_RE = /^[a-z][a-z0-9-]{0,31}$/;
-
-/**
- * 保留路径段：这些第一段**不可能**是应用标识。
- *
- * 没有这张表时，'/api/todo/list' 的第一段 'api' 会被当成 app 名 ——
- * 合法字符、全小写、还长得像个应用 —— 于是请求被路由到不存在的 app。
- * 这张表把服务自身的路径前缀排除掉。
- */
-const RESERVED_PATH_SEGMENTS = new Set([
-  'api', 'auth', 'health', 'stats', 'clients', 'push', 'ws',
-  'files', 'assets', 'static', 'docs', 'favicon.ico',
-]);
-
-function isValidAppName(name) {
-  return typeof name === 'string' && APP_NAME_RE.test(name);
-}
-
-/**
- * 解析一个 app 的本地基址。
- *
- * 优先用配置里给的 base；没给就用已知端口兜底。
- * 返回 null 表示这个 app 没有可用的本地端口。
- */
-function baseOf(app, overrides) {
-  const over = overrides && overrides[app];
-  if (over && over.base) return over.base;
-  const known = KNOWN_APPS[app];
-  if (!known) return null;
-  return `http://127.0.0.1:${known.port}`;
-}
-
-/**
- * 探测本机某个端口是否在监听。
- *
- * 用 TCP connect 而不是 HTTP 请求：桥接关心的是「这个服务在不在」，
- * 不是「它返回什么」。连不上就是不在，不多问。
- */
-function probePort(host, port, timeoutMs = 400) {
-  return new Promise((resolve) => {
-    const socket = new net.Socket();
-    let settled = false;
-    const done = (ok) => {
-      if (settled) return;
-      settled = true;
-      try { socket.destroy(); } catch { /* ignore */ }
-      resolve(ok);
-    };
-    socket.setTimeout(timeoutMs);
-    socket.once('connect', () => done(true));
-    socket.once('timeout', () => done(false));
-    socket.once('error', () => done(false));
-    socket.connect(port, host);
-  });
-}
-
-/**
- * 扫描本机各已知 app 的端口，返回可桥接清单（含存活状态）。
- *
- * 注意返回的是「候选清单」——**能不能桥由配置决定**，这里只提供事实。
- */
-async function scanApps({ host = '127.0.0.1', apps = null, overrides = null } = {}) {
-  const names = apps && apps.length ? apps : Object.keys(KNOWN_APPS);
-  const out = [];
-  for (const app of names) {
-    const base = baseOf(app, overrides);
-    const known = KNOWN_APPS[app];
-    const port = known ? known.port : (base ? new URL(base).port : null);
-    const alive = port ? await probePort(host, Number(port)) : false;
-    out.push({
-      app,
-      title: known ? known.title : app,
-      base,
-      port: port ? Number(port) : null,
-      alive,
-    });
-  }
-  return out;
-}
-
-/**
- * 检查某个端口能不能绑（= 现在没人占）。
- *
- * 为什么要预检：**静默顺延端口是这里最坏的处理**。server 顺延到 7778，
- * 客户端还按 7777 去连 —— 连不上还是连不上，而用户看到的现象是
- * 「服务端说起来了、客户端说连不上」，两边对不上账。宁可**明确报错退出**。
- */
-function isPortFree(port, host = '127.0.0.1') {
-  return new Promise((resolve) => {
-    const server = net.createServer();
-    let settled = false;
-    const done = (free, err) => {
-      if (settled) return;
-      settled = true;
-      try { server.close(); } catch { /* ignore */ }
-      resolve({ free, error: err || null });
-    };
-    server.once('error', (e) => done(false, e));
-    server.once('listening', () => done(true, null));
-    try {
-      server.listen(port, host);
-    } catch (e) {
-      done(false, e);
-    }
-  });
-}
-
-/**
- * 描述一个可桥接应用的元信息。
- *
- * client half 注册时把这份元信息一并报给 server half，server 把它汇总成
- * **元信息目录**（catalog）—— 远端客户端登录后先拉目录，看到「哪些能路由、
- * 各自是什么」，再决定调哪个。
- *
- * @param {string} app
- * @param {string} base   本地基址，如 http://127.0.0.1:7877
- */
-function describeApp(app, base) {
-  const known = KNOWN_APPS[app] || null;
-  let port = null;
-  try {
-    port = base ? Number(new URL(base).port || '') || null : null;
-  } catch {
-    port = null;
-  }
-  return {
-    app,
-    base,
-    port: port || (known ? known.port : null),
-    title: known ? known.title : app,
-    known: !!known,
-  };
-}
-
-/**
- * 从请求里解析出应用标识与剩余路径。
- *
- * @param {string} pathname  请求路径（不含 query）
- * @param {object} headers  规范化后的小写头对象
- * @returns {{app: string, path: string} | {error: string}}
- */
-function resolveApp(pathname, headers) {
-  const segs = String(pathname || '/').split('/').filter(Boolean);
-
-  // ① 路径前缀：第一段就是已知/声明过的 app 名（且不是服务自身的保留段）
-  let pathApp = null;
-  if (segs.length
-      && isValidAppName(segs[0])
-      && !RESERVED_PATH_SEGMENTS.has(segs[0])) {
-    pathApp = segs[0];
-  }
-
-  // ② 请求头
-  let headerApp = null;
-  const hv = headers && headers[APP_HEADER];
-  if (hv && hv.length) {
-    const v = String(hv[0]).trim();
-    if (v) {
-      if (!isValidAppName(v)) return { error: 'invalid_app_name' };
-      headerApp = v;
-    }
-  }
-
-  if (pathApp && headerApp && pathApp !== headerApp) {
-    return { error: 'app_conflict' };
-  }
-  const app = pathApp || headerApp;
-  if (!app) return { error: 'app_required' };
-
-  const rest = pathApp ? segs.slice(1) : segs;
-  const path = '/' + rest.join('/');
-  return { app, path: path === '/' ? '/' : path.replace(/\/+$/, '') };
-}
-
-module.exports = {
-  APP_HEADER,
-  RESERVED_PATH_SEGMENTS,
-  KNOWN_APPS,
-  APP_NAME_RE,
-  isValidAppName,
-  baseOf,
-  describeApp,
-  probePort,
-  isPortFree,
-  scanApps,
-  resolveApp,
-};

package/lib/auth.js

@@ -1,319 +0,0 @@
-'use strict';
-
-/**
- * 统一登录：`mn-ws auth login`。
- *
- * 流程与 mn-rt 的 `auth login` **完全同款**（全程零复制粘贴）：
- *   ① GET  <server>/auth/oidc/config     问服务端"认证中心在哪、用哪个 client"
- *   ② 本机 127.0.0.1:<随机端口> 起一次性监听，生成 PKCE，打开系统浏览器
- *   ③ 用户在认证中心登录 → 302 回本机监听 → 拿到 code
- *   ④ 用 code + verifier 直接在**认证中心**换 access_token（公共客户端，无 secret）
- *   ⑤ 带 Bearer 调 <server>/auth/verify → 换回 mn-ws 自己的设备令牌
- *   ⑥ 落盘到 ~/.mn-ws/config.json，之后 client / server 静默携带
- *
- * ── 为什么第 ④ 步由 CLI 自己换、而不是把 code 交给服务端换 ──────────────
- * 交给服务端换需要服务端自己发起 authorize 并持有 PKCE verifier —— 那就多一份
- * RP 会话（cookie/存储）要实现。CLI 自己换 token 则只需登记回环通配
- * （127.0.0.1 端口任意、路径固定 /callback）—— RFC 8252 给原生客户端的标准做法。
- *
- * ── 为什么不存 refresh_token ────────────────────────────────────────────
- * 第 ④ 步换到的 refresh_token 直接丢弃。CLI 真正需要长期持有的是第 ⑤ 步
- * 服务端签发的**设备令牌**——它可被服务端吊销，而 refresh_token 一旦落到
- * 每台机器的磁盘上，就是把「谁拿到谁可用 7 天」的凭据复制到 N 台机器。
- */
-
-const http = require('http');
-const crypto = require('crypto');
-const { execFile } = require('child_process');
-const { URL } = require('url');
-
-/** CLI 侧回环回调地址。端口 0 让内核分配，再回填进 authorize 请求。 */
-const LOOPBACK_PATH = '/callback';
-/** 等用户完成登录的时间上限（5 分钟）。 */
-const LOGIN_TIMEOUT_MS = 5 * 60 * 1000;
-
-function b64url(buf) {
-  return Buffer.from(buf).toString('base64')
-    .replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
-}
-
-/**
- * 生成 PKCE 与一次性参数。
- *
- * 注意 state 只有**一个**值：authorizeParams 里的那个就是真正发出去的，
- * 也是回调回来后要比对的。曾经同时返回两个独立随机值，导致每次登录都必然
- * 报 state 不一致 —— 这里只留一份。
- */
-function createAuthRequest(redirectUri) {
-  const verifier = b64url(crypto.randomBytes(32));
-  const challenge = b64url(crypto.createHash('sha256').update(verifier).digest());
-  const state = b64url(crypto.randomBytes(16));
-  return {
-    verifier,
-    state,
-    nonce: b64url(crypto.randomBytes(16)),
-    authorizeParams: {
-      response_type: 'code',
-      redirect_uri: redirectUri,
-      code_challenge: challenge,
-      code_challenge_method: 'S256',
-      state,
-    },
-  };
-}
-
-/**
- * 起一次性回环监听，等浏览器把 code 送回来。
- * 只绑 127.0.0.1：绑 0.0.0.0 会让同网段任何人都能来抢这个 code。
- */
-function openLoopback() {
-  let server;
-  let resolveFn;
-  let rejectFn;
-  const got = new Promise((res, rej) => { resolveFn = res; rejectFn = rej; });
-
-  return {
-    start() {
-      return new Promise((resolve, reject) => {
-        server = http.createServer((req, res) => {
-          const u = new URL(req.url, 'http://127.0.0.1');
-          if (u.pathname !== LOOPBACK_PATH) { res.writeHead(404).end(); return; }
-          const err = u.searchParams.get('error');
-          if (err) {
-            res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' })
-              .end('<h3>授权未通过</h3><p>可以关闭这个页面了。</p>');
-            rejectFn(new Error(`授权被拒绝：${err}`));
-            return;
-          }
-          const code = u.searchParams.get('code');
-          const state = u.searchParams.get('state');
-          if (!code) { rejectFn(new Error('回调里没有 code')); return; }
-          res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' })
-            .end('<h3>✅ 已收到授权</h3><p>可以关闭浏览器，回到终端了。</p>');
-          resolveFn({ code, state });
-        });
-        server.once('error', reject);
-        server.listen(0, '127.0.0.1', () => {
-          const { port } = server.address();
-          resolve(`http://127.0.0.1:${port}${LOOPBACK_PATH}`);
-        });
-      });
-    },
-    wait: (ms = LOGIN_TIMEOUT_MS) => Promise.race([
-      got,
-      new Promise((_, rej) => setTimeout(() => rej(new Error('登录超时（5 分钟未完成）')), ms)
-        .unref?.()),
-    ]),
-    close() { try { server && server.close(); } catch { /* ignore */ } },
-  };
-}
-
-/**
- * 各平台打开浏览器的命令与参数。
- *
- * ── Windows 为什么绝不借道 `cmd /c start` ────────────────────────────────
- * 授权 URL 里全是 `&`。Node execFile 对不含空格的参数不加引号，命令行到达
- * cmd.exe 后 `&` 被**当成命令分隔符**：浏览器只收到第一个 `&` 之前的部分，
- * redirect_uri / code_challenge 全被切掉，报「redirect_uri 未在白名单内」。
- * rundll32 的 FileProtocolHandler 不经任何 shell 解析，命令行原样到达。
- */
-function openBrowserArgs(platform, url) {
-  if (platform === 'darwin') return ['open', [url]];
-  if (platform === 'win32') return ['rundll32', ['url.dll,FileProtocolHandler', url]];
-  return ['xdg-open', [url]];
-}
-
-function openBrowser(url) {
-  const [cmd, args] = openBrowserArgs(process.platform, url);
-  execFile(cmd, args, { detached: true, stdio: 'ignore' }, (e) => {
-    if (e) {
-      process.stderr.write(
-        `自动打开浏览器失败（${e.message.split('\n')[0]}），请手动打开上面打印的授权地址\n`);
-    }
-  });
-}
-
-/** 向任意 URL 发 JSON / 表单请求并解析 JSON。 */
-function postJson(urlStr, { body, headers = {}, form } = {}) {
-  return new Promise((resolve, reject) => {
-    let u;
-    try { u = new URL(urlStr); } catch { reject(new Error(`非法地址: ${urlStr}`)); return; }
-    const payload = form ? new URLSearchParams(form).toString() : JSON.stringify(body || {});
-    const req = http.request({
-      method: 'POST',
-      hostname: u.hostname,
-      port: u.port || 80,
-      path: u.pathname + u.search,
-      headers: {
-        'Content-Type': form ? 'application/x-www-form-urlencoded' : 'application/json',
-        'Content-Length': Buffer.byteLength(payload),
-        ...headers,
-      },
-      timeout: 15_000,
-    }, (res) => {
-      let raw = '';
-      res.on('data', (c) => { raw += c; });
-      res.on('end', () => {
-        let json = null;
-        try { json = JSON.parse(raw); } catch { /* 非 JSON 就当原文 */ }
-        resolve({ status: res.statusCode, json, raw });
-      });
-    });
-    req.on('timeout', () => { req.destroy(new Error('请求超时')); });
-    req.on('error', reject);
-    req.write(payload);
-    req.end();
-  });
-}
-
-/** GET 一个 URL 并解析 JSON。 */
-function getJson(urlStr, { headers = {} } = {}) {
-  return new Promise((resolve, reject) => {
-    let u;
-    try { u = new URL(urlStr); } catch { reject(new Error(`非法地址: ${urlStr}`)); return; }
-    const req = http.request({
-      method: 'GET',
-      hostname: u.hostname,
-      port: u.port || 80,
-      path: u.pathname + u.search,
-      headers,
-      timeout: 15_000,
-    }, (res) => {
-      let raw = '';
-      res.on('data', (c) => { raw += c; });
-      res.on('end', () => {
-        let json = null;
-        try { json = JSON.parse(raw); } catch { /* 非 JSON 就当原文 */ }
-        resolve({ status: res.statusCode, json, raw });
-      });
-    });
-    req.on('timeout', () => { req.destroy(new Error('请求超时')); });
-    req.on('error', reject);
-    req.end();
-  });
-}
-
-/** 组 authorize URL。 */
-function buildAuthorizeUrl(cfg, req, { promptLogin = false } = {}) {
-  const authorizeUrl = new URL(cfg.authorizationEndpoint || `${cfg.issuer}/oauth2/auth`);
-  authorizeUrl.searchParams.set('client_id', cfg.clientId);
-  authorizeUrl.searchParams.set('scope', (cfg.scopes || ['openid', 'profile', 'email']).join(' '));
-  authorizeUrl.searchParams.set('state', req.state);
-  authorizeUrl.searchParams.set('nonce', req.nonce);
-  for (const [k, v] of Object.entries(req.authorizeParams)) authorizeUrl.searchParams.set(k, v);
-  if (promptLogin) authorizeUrl.searchParams.set('prompt', 'login');
-  return authorizeUrl.toString();
-}
-
-/**
- * 用 access_token 换 mn-ws 自己的设备令牌。
- * @returns {{userId,email,username,nickname,token,tokenExpiresAt,clientId,deviceName}}
- */
-async function verifyExchange({ serverHttp, accessToken, clientId, deviceName }) {
-  const base = (serverHttp || '').replace(/\/+$/, '');
-  const res = await postJson(`${base}/auth/verify`, {
-    headers: { Authorization: `Bearer ${accessToken}` },
-    body: { clientId, deviceName },
-  });
-  const j = res.json || {};
-  if (!res.status || res.status >= 400 || !j.token) {
-    const err = new Error(j.error || res.raw || `HTTP ${res.status}`);
-    err.code = j.code;
-    throw err;
-  }
-  return {
-    userId: j.userId || '',
-    email: j.email || '',
-    username: j.username || '',
-    nickname: j.nickname || '',
-    token: j.token,
-    tokenExpiresAt: j.tokenExpiresAt || 0,
-    clientId: j.clientId || clientId || '',
-    deviceName: j.deviceName || deviceName || '',
-  };
-}
-
-/**
- * 完整登录一次。
- * @param {object} opts
- * @param {string} opts.serverHttp
- * @param {string} opts.clientId
- * @param {string} [opts.deviceName]
- * @param {boolean} [opts.noOpen]      只打印地址不弹浏览器
- * @param {(url:string)=>void} [opts.onUrl]
- * @param {boolean} [opts.promptLogin]  authorize 带 prompt=login（换人登录用）
- */
-async function authLogin(opts) {
-  const base = (opts.serverHttp || '').replace(/\/+$/, '');
-  if (!base) throw new Error('缺少服务端地址（--url 或配置文件）');
-
-  const cfgRes = await getJson(`${base}/auth/oidc/config`);
-  const cfg = cfgRes.json || {};
-  if (!cfg.enabled) {
-    throw new Error('服务端未开启统一登录（MN_WS_AUTH_ENABLED）。'
-      + '旧用法仍可用：client --token <门禁token>');
-  }
-  if (!cfg.issuer || !cfg.clientId) {
-    throw new Error(`服务端统一登录配置不完整：${JSON.stringify(cfg)}`);
-  }
-
-  const lb = openLoopback();
-  const redirectUri = await lb.start();
-  const req = createAuthRequest(redirectUri);
-
-  const authorizeUrl = new URL(buildAuthorizeUrl(cfg, req, { promptLogin: opts.promptLogin === true }));
-
-  if (opts.onUrl) opts.onUrl(authorizeUrl.toString());
-  if (opts.noOpen) {
-    lb.close();
-    return { authorizeUrl: authorizeUrl.toString(), redirectUri, pending: true };
-  }
-  openBrowser(authorizeUrl.toString());
-
-  let callback;
-  try {
-    callback = await lb.wait();
-  } finally {
-    lb.close();
-  }
-  // state 不匹配只有两种可能：回调被串了，或有人在伪造一次登录完成。都必须中止。
-  if (callback.state !== req.state) throw new Error('state 不一致，已中止登录');
-
-  // ④ CLI 自己换 token（公共客户端 + PKCE，无 secret）
-  const tokRes = await postJson(cfg.tokenEndpoint || `${cfg.issuer}/oauth2/token`, {
-    form: {
-      grant_type: 'authorization_code',
-      code: callback.code,
-      client_id: cfg.clientId,
-      redirect_uri: redirectUri,
-      code_verifier: req.verifier,
-    },
-  });
-  const tok = tokRes.json || {};
-  if (!tokRes.status || tokRes.status >= 400 || !tok.access_token) {
-    throw new Error(`换 token 失败：${tok.error || tokRes.raw || `HTTP ${tokRes.status}`}`);
-  }
-
-  // ⑤ 换 mn-ws 自己的设备令牌
-  const res = await verifyExchange({
-    serverHttp: base,
-    accessToken: tok.access_token,
-    clientId: opts.clientId,
-    deviceName: opts.deviceName,
-  });
-
-  return { ...res, clientId: res.clientId || opts.clientId || '' };
-}
-
-module.exports = {
-  authLogin,
-  buildAuthorizeUrl,
-  createAuthRequest,
-  openLoopback,
-  openBrowser,
-  getJson,
-  postJson,
-  b64url,
-  LOOPBACK_PATH,
-  LOGIN_TIMEOUT_MS,
-};