t880216t-server 1.5.20

package/lib/plugins/whistle.nohost/lib/uiServer/cgi/redirect.js

@@ -0,0 +1,10 @@
+const { getClientId } = require('../../util');
+
+module.exports = (ctx) => {
+  const { url, name, env } = ctx.request.query;
+  const account = ctx.accountMgr.getAccount(name);
+  if (account) {
+    ctx.envMgr.setEnv(getClientId(ctx), name, env);
+  }
+  ctx.redirect(url || './');
+};

package/lib/plugins/whistle.nohost/lib/uiServer/cgi/selectEnv.js

@@ -0,0 +1,30 @@
+const { COOKIE_NAME, ENV_MAX_AGE, decodeURIComponentSafe, getClientId } = require('../../util');
+
+module.exports = (ctx) => {
+  const { name, envId, redirect } = ctx.request.query;
+  let envName;
+  // 如果 envId 看起来像短ID（不包含编码的环境名特征），则通过 envId 查找 envName
+  if (envId && !envId.includes('%')) {
+    envName = ctx.accountMgr.getEnvNameById(name, envId);
+    // 如果没找到，回退到直接解码（兼容旧逻辑）
+    if (!envName) {
+      envName = decodeURIComponentSafe(envId);
+    }
+  } else {
+    envName = decodeURIComponentSafe(envId);
+  }
+  const env = ctx.envMgr.setEnv(getClientId(ctx), name, envName);
+  let value = '';
+  if (env) {
+    value = encodeURIComponent(`${name}/${env.envName}`);
+  }
+  ctx.cookies.set(COOKIE_NAME, value, {
+    path: '/',
+    expires: new Date(Date.now() + (ENV_MAX_AGE * 1000)),
+  });
+  if (redirect && typeof redirect === 'string') {
+    ctx.redirect(redirect);
+  } else {
+    ctx.body = { ec: 0 };
+  }
+};

package/lib/plugins/whistle.nohost/lib/uiServer/cgi/unfollow.js

@@ -0,0 +1,4 @@
+module.exports = (ctx) => {
+  ctx.envMgr.unfollow(ctx);
+  ctx.body = { ec: 0 };
+};

package/lib/plugins/whistle.nohost/lib/uiServer/index.js

@@ -0,0 +1,60 @@
+const Koa = require('koa');
+const onerror = require('koa-onerror');
+const serve = require('koa-static');
+const path = require('path');
+const router = require('koa-router')();
+const setupRouter = require('./router');
+const accountMgr = require('../accountMgr');
+const envMgr = require('../envMgr');
+const whistleMgr = require('../whistleMgr');
+
+const MAX_AGE = 1000 * 60 * 5;
+const error = function (em, ec) {
+  em = em || '请求失败，请刷新页面重试';
+  ec = ec || 2;
+  this.body = { ec, em };
+};
+
+module.exports = (server, options) => {
+  const { username, password } = options.data;
+  const { runtimeId } = options.config;
+  const app = new Koa();
+  app.proxy = true;
+  app.silent = true;
+  if (process.env.PFORK_MODE === 'bind') {
+    onerror(app);
+  }
+  app.use(async (ctx, next) => {
+    const baseUrl = `http://${accountMgr.getBaseUrl()}/`;
+    ctx.baseUrl = baseUrl;
+    ctx.success = function () {
+      this.body = { ec: 0, baseUrl };
+    };
+    ctx.error = error;
+    ctx.accountMgr = accountMgr;
+    ctx.envMgr = envMgr;
+    ctx.config = options.config;
+    ctx.updateRules = options.updateRules;
+    ctx.whistleMgr = whistleMgr;
+    ctx.admin = { username, password };
+    ctx.runtimeId = runtimeId;
+    ctx.set('x-nohost-base-url', baseUrl);
+    const { path: pathname } = ctx;
+    if (pathname === '/' || pathname === '/index.html') {
+      ctx.req.url = '/select.html';
+    } else if (pathname === '/js/nohost.js') {
+      ctx.req.url = '/button.js';
+    }
+    const origin = ctx.get('origin');
+    if (origin) {
+      ctx.set('Access-Control-Allow-Origin', origin);
+      ctx.set('Access-Control-Allow-Credentials', true);
+    }
+    await next();
+  });
+  setupRouter(router);
+  app.use(router.routes());
+  app.use(router.allowedMethods());
+  app.use(serve(path.join(__dirname, '../../../../../public/'), { maxage: MAX_AGE }));
+  server.on('request', app.callback());
+};

package/lib/plugins/whistle.nohost/lib/uiServer/network.js

@@ -0,0 +1,38 @@
+
+const startWhistle = require('whistle');
+const path = require('path');
+const { getNohostPluginsPath, getPort, PLUGINS_DIR } = require('../util');
+
+let result;
+const projectPluginsPath = [
+  path.join(__dirname, '../../../account'),
+];
+const customPluginsPath = [
+  path.join(getNohostPluginsPath(), 'worker_plugins'),
+];
+const pluginsPath = [
+  path.join(PLUGINS_DIR, 'whistle.nohost/lib/node_modules'),
+  path.join(PLUGINS_DIR, 'whistle.nohost/node_modules'),
+];
+
+module.exports = () => {
+  if (!result) {
+    result = new Promise((resolve) => {
+      getPort((port) => {
+        const proxy = startWhistle({
+          globalData: 'Network',
+          cmdName: 'n2',
+          port,
+          host: '127.0.0.1',
+          encrypted: true,
+          storage: 'nohost_network_mode',
+          mode: 'plugins|disableUpdateTips|hideLeftMenu',
+          projectPluginsPath,
+          customPluginsPath,
+          pluginsPath,
+        }, () => resolve(port, proxy));
+      });
+    });
+  }
+  return result;
+};

package/lib/plugins/whistle.nohost/lib/uiServer/openAPI.js

@@ -0,0 +1,94 @@
+const proxy = require('./cgi/proxy');
+const accountMgr = require('../accountMgr');
+const { AUTH_KEY } = require('../util');
+
+const CGI_MAP = {
+  'add-env': 'rules/add',
+  'add-top-env': 'rules/project',
+  'add-top-rules': 'rules/project',
+  'add-rules': 'rules/add',
+  'modify-env': 'rules/add',
+  'modify-rules': 'rules/add',
+  'remove-env': 'rules/remove',
+  'remove-rules': 'rules/remove',
+  'rename-env': 'rules/rename',
+  'rename-rules': 'rules/rename',
+  list: 'rules/list',
+};
+
+const getRules = (options) => {
+  const { account, name, env, envName, envId } = options;
+  let rules = '';
+  let headers;
+  // 如果传入了 envId，优先使用 envId 查询
+  if (envId && (account || name)) {
+    const result = accountMgr.getRulesByEnvId(account || name, envId);
+    rules = result.rules || '';
+    headers = result.headers;
+  } else {
+    const result = accountMgr.getRules(account || name, env || envName);
+    rules = result.rules || '';
+    headers = result.headers;
+  }
+  if (headers) {
+    headers = JSON.stringify(headers);
+    if (headers.length > 2) {
+      rules += `\n* reqHeaders://(${headers})`;
+    }
+  }
+  return rules;
+};
+
+module.exports = async (ctx, next) => {
+  let { cgiName } = ctx.params;
+  const authKey = ctx.accountMgr.getAuthKey();
+  if (cgiName === 'rules') {
+    const { query } = ctx.request;
+    if (!authKey || authKey !== query.authKey) {
+      ctx.status = 403;
+      return;
+    }
+    ctx.body = getRules(query);
+    return;
+  }
+
+  // Handle rename-env specially to preserve env id
+  if (cgiName === 'rename-env') {
+    const name = ctx.get('x-nohost-account-name');
+    const account = ctx.accountMgr.getAccount(name);
+    if (!account) {
+      return;
+    }
+    const curAuthKey = authKey && ctx.get('x-nohost-auth-key');
+    if (!curAuthKey || (authKey !== curAuthKey && curAuthKey !== ctx.accountMgr.defaultAuthKey)) {
+      ctx.status = 403;
+      return;
+    }
+    const { query } = ctx.request;
+    const oldName = query.name;
+    const newName = query.newValue || query.newName;
+    if (oldName && newName) {
+      ctx.accountMgr.renameEnv(name, oldName, newName);
+    }
+  }
+
+  cgiName = CGI_MAP[cgiName];
+  const name = ctx.get('x-nohost-account-name');
+  const account = cgiName && ctx.accountMgr.getAccount(name);
+  if (!account) {
+    return;
+  }
+  const curAuthKey = authKey && ctx.get('x-nohost-auth-key');
+  if (!curAuthKey || (authKey !== curAuthKey && curAuthKey !== ctx.accountMgr.defaultAuthKey)) {
+    ctx.status = 403;
+    return;
+  }
+  const { req } = ctx;
+  req.headers['x-whistle-auth-key'] = AUTH_KEY;
+  let { url } = req;
+  const index = url.indexOf('?');
+  url = index === -1 ? '' : url.substring(index);
+  req.url = `/account/${name}/cgi-bin/${cgiName}${url}`;
+  ctx.account = account;
+  await proxy(ctx, next);
+};

package/lib/plugins/whistle.nohost/lib/uiServer/router.js

@@ -0,0 +1,85 @@
+const bodyParser = require('koa-bodyparser');
+const list = require('./cgi/list');
+const proxyNetwork = require('./cgi/proxyNetwork');
+const selectEnv = require('./cgi/selectEnv');
+const checkAdminLogin = require('./cgi/admin/login');
+const getAllAccounts = require('./cgi/admin/allAccounts');
+const addAccount = require('./cgi/admin/addAccount');
+const moveAccount = require('./cgi/admin/move');
+const activeAccount = require('./cgi/admin/activeAccount');
+const removeAccount = require('./cgi/admin/removeAccount');
+const getSettings = require('./cgi/admin/getSettings');
+const setJsonData = require('./cgi/admin/setJsonData');
+const setRulesTpl = require('./cgi/admin/setRulesTpl');
+const setEntryPatterns = require('./cgi/admin/setEntryPatterns');
+const setTestRules = require('./cgi/admin/setTestRules');
+const setDefaultRules = require('./cgi/admin/setDefaultRules');
+const setAccountRules = require('./cgi/admin/setAccountRules');
+const getAuthKey = require('./cgi/admin/getAuthKey');
+const setAuthKey = require('./cgi/admin/setAuthKey');
+const enableGuest = require('./cgi/admin/enableGuest');
+const proxy = require('./cgi/proxy');
+const getEntryRules = require('./cgi/entryRules');
+const getPluginRules = require('./cgi/pluginRules');
+const changePassword = require('./cgi/account/changePassword');
+const patterns = require('./cgi/patterns');
+const allowlist = require('./cgi/allowlist');
+const openAPI = require('./openAPI');
+const follow = require('./cgi/follow');
+const unfollow = require('./cgi/unfollow');
+const redirect = require('./cgi/redirect');
+const getEnv = require('./cgi/getEnv');
+const changeAdminPassword = require('./cgi/admin/changePassword');
+const changeNotice = require('./cgi/admin/changeNotice');
+const setSpecPattern = require('./cgi/admin/specPattern');
+
+const defaultBodyParser = bodyParser({ formLimit: '1mb' });
+const forwardCapture = async (ctx, next) => {
+  ctx.url = '/capture.html';
+  await next();
+};
+
+module.exports = (router) => {
+  router.get('/admin.html', checkAdminLogin);
+  router.all('/cgi-bin/admin/(.*)', checkAdminLogin);
+  router.all('/cgi-bin/(.*)', defaultBodyParser);
+  router.get('/open-api/select', defaultBodyParser, selectEnv);
+  router.get('/open-api/cur-env', defaultBodyParser, getEnv);
+  router.get('/open-api/get-env', defaultBodyParser, getEnv);
+  router.all('/open-api/:cgiName', openAPI);
+  router.get('/cgi-bin/list', list);
+  router.get('/cgi-bin/cur-env', getEnv);
+  router.get('/cgi-bin/get-env', getEnv);
+  router.get('/cgi-bin/rules', getEntryRules);
+  router.get('/cgi-bin/entry-rules', getEntryRules);
+  router.get('/cgi-bin/remote-rules', getPluginRules);
+  router.get('/cgi-bin/plugin-rules', getPluginRules);
+  router.all('/network/(.*)', proxyNetwork);
+  router.get('/data.html', forwardCapture);
+  router.get('/cgi-bin/select', selectEnv);
+  router.get('/cgi-bin/admin/all-accounts', getAllAccounts);
+  router.post('/cgi-bin/admin/add-account', addAccount);
+  router.post('/cgi-bin/admin/move', moveAccount);
+  router.post('/cgi-bin/admin/active-account', activeAccount);
+  router.post('/cgi-bin/admin/remove-account', removeAccount);
+  router.post('/cgi-bin/admin/change-password', changeAdminPassword);
+  router.post('/cgi-bin/admin/change-notice', changeNotice);
+  router.post('/cgi-bin/admin/enable-guest', enableGuest);
+  router.post('/cgi-bin/admin/set-entry-patterns', setEntryPatterns);
+  router.get('/cgi-bin/admin/get-settings', getSettings);
+  router.post('/cgi-bin/admin/set-json-data', setJsonData);
+  router.post('/cgi-bin/admin/set-rules-tpl', setRulesTpl);
+  router.post('/cgi-bin/admin/set-test-rules', setTestRules);
+  router.post('/cgi-bin/admin/set-default-rules', setDefaultRules);
+  router.post('/cgi-bin/admin/set-account-rules', setAccountRules);
+  router.get('/cgi-bin/admin/get-auth-key', getAuthKey);
+  router.post('/cgi-bin/admin/set-auth-key', setAuthKey);
+  router.post('/cgi-bin/admin/set-spec-pattern', setSpecPattern);
+  router.get('/cgi-bin/patterns', patterns);
+  router.get('/cgi-bin/allowlist', allowlist);
+  router.all('/account/:name/(.*)', proxy);
+  router.post('/cgi-bin/account/change-password', changePassword);
+  router.get('/follow', follow);
+  router.get('/unfollow', unfollow);
+  router.get('/redirect', redirect);
+};

package/lib/plugins/whistle.nohost/lib/util.js

@@ -0,0 +1,230 @@
+const crypto = require('crypto');
+const net = require('net');
+const parseurl = require('parseurl');
+const http = require('http');
+const HOME_DIR = require('os').homedir();
+const path = require('path');
+const { getWhistlePath } = require('whistle');
+
+const ENV_MAX_AGE = 60 * 60 * 24 * 3;
+const MAX_CLIENT_ID_LEN = 100;
+const CONF_KEY_RE = /^([\w-]{1,64}:?|[\w.-]{1,64}:)$/;
+
+exports.AUTH_KEY = `${Date.now()}/${Math.random()}`;
+exports.loadModule = require;
+exports.ENV_MAX_AGE = ENV_MAX_AGE;
+exports.WHISTLE_ENV_HEADER = 'x-whistle-nohost-env';
+exports.CONFIG_DATA_TYPE = 'PROXY_CONFIG';
+exports.COOKIE_NAME = 'whistle_nohost_env';
+exports.WHISTLE_RULE_VALUE = 'x-whistle-rule-value';
+exports.BASE_URL = 'http://local.whistlejs.com/plugin.nohost/';
+
+const PLUGINS_DIR = path.resolve(HOME_DIR, 'whistle-plugins');
+exports.PLUGINS_DIR = PLUGINS_DIR;
+
+const LOCALHOST = '127.0.0.1';
+const STRIDE = 5;
+let curPort = Math.floor(20001 + (10000 * Math.random()));
+curPort = (curPort + 1) - (curPort % STRIDE);
+
+const getPort = (callback) => {
+  const server = http.createServer();
+  server.on('error', () => {
+    if (++curPort % 5 === 0) {
+      ++curPort;
+    }
+    getPort(callback);
+  });
+  server.listen(curPort, LOCALHOST, () => {
+    server.removeAllListeners();
+    server.close(() => callback(curPort));
+  });
+};
+
+exports.getPort = getPort;
+
+/* eslint-disable no-empty */
+const shasum = (str) => {
+  if (typeof str !== 'string') {
+    str = '';
+  }
+  const result = crypto.createHash('sha1');
+  result.update(str);
+  return result.digest('hex');
+};
+exports.shasum = shasum;
+
+const decodeURIComponentSafe = (str) => {
+  if (typeof str !== 'string') {
+    return '';
+  }
+  try {
+    return decodeURIComponent(str);
+  } catch (e) {}
+  return str;
+};
+
+exports.decodeURIComponentSafe = decodeURIComponentSafe;
+
+const parseJSON = (str) => {
+  try {
+    const result = JSON.parse(str);
+    if (typeof result === 'object') {
+      return result;
+    }
+  } catch (e) {}
+};
+
+exports.parseJSON = parseJSON;
+
+const transformReq = (req, port, host) => {
+  const options = parseurl(req);
+  options.host = host || '127.0.0.1';
+  options.method = req.method;
+  options.headers = req.headers;
+  delete options.headers.referer;
+  delete options.protocol;
+  delete options.hostname;
+  if (port > 0) {
+    options.port = port;
+  }
+  return new Promise((resolve, reject) => {
+    const client = http.request(options, resolve);
+    client.on('error', reject);
+    req.pipe(client);
+  });
+};
+
+exports.transformReq = transformReq;
+exports.transformWhistle = async (ctx, port) => {
+  const { req } = ctx;
+  const res = await transformReq(req, port);
+  ctx.status = res.statusCode;
+  ctx.set(res.headers);
+  ctx.body = res;
+};
+
+exports.parseConfig = (ctn) => {
+  if (typeof ctn !== 'string') {
+    return;
+  }
+  ctn = ctn.trim().split(/\r\n|\r|\n/g);
+  let conf;
+  ctn.forEach((line) => {
+    line = line.replace(/#.*$/, '').trim().split(/\s+/);
+    if (line.length) {
+      let key = line[0].toLowerCase();
+      if (!key || !CONF_KEY_RE.test(key)) {
+        return;
+      }
+      conf = conf || {};
+      key = key.replace(':', '');
+      if (key !== 'host') {
+        key = `x-nohost-${key}`;
+      }
+      if (conf[key] == null && (!conf.headers || conf.headers[key] == null)) {
+        if (key === 'host') {
+          conf.host = line[1];
+        } else {
+          conf.headers = conf.headers || {};
+          conf.headers[key] = line[1] || '';
+        }
+      }
+    }
+  });
+  return conf;
+};
+
+const KEY_RE = /(?:@([^\s@]+)|\{([^\s@]+)\})/ig;
+const resolveConf = (ctn, values) => {
+  if (!ctn || !values) {
+    return ctn;
+  }
+  return ctn.replace(KEY_RE, (all, $1, $2) => {
+    return values[$1 || $2] || '';
+  });
+};
+
+exports.resolveConfList = (list, publicList) => {
+  if (!list.length || !publicList || !publicList.length) {
+    return list;
+  }
+  const map = {};
+  publicList.forEach((conf) => {
+    map[conf.name] = conf.rules || '';
+  });
+  list.forEach((conf) => {
+    conf.rules = resolveConf(conf.rules, map);
+  });
+  return list;
+};
+
+let REQ_FROM_HEADER;
+let RULE_VALUE_HEADER;
+
+exports.initPlugin = (options) => {
+  RULE_VALUE_HEADER = options.RULE_VALUE_HEADER;
+  REQ_FROM_HEADER = options.config.REQ_FROM_HEADER;
+  exports.config = options.config;
+  exports.pluginConfig = options.data;
+};
+
+exports.getRuleValue = (ctx) => {
+  const ruleValue = ctx.get(RULE_VALUE_HEADER);
+  return ruleValue ? decodeURIComponent(ruleValue) : '';
+};
+
+exports.isFromComposer = (ctx) => {
+  return ctx.get(REQ_FROM_HEADER) === 'W2COMPOSER';
+};
+
+exports.getDomain = function (hostname) {
+  if (net.isIP(hostname)) {
+    return hostname;
+  }
+  let list = hostname.split('.');
+  const len = list.length;
+  if (len < 3) {
+    return hostname;
+  }
+  let wildcard = len > 3;
+  if (wildcard) {
+    list = list.slice(-3);
+  }
+
+  if (list[1].length > 3 || list[1] === 'url' || list[2] === 'com') {
+    wildcard = true;
+    list = list.slice(-2);
+  }
+  if (wildcard) {
+    list.unshift('');
+  }
+  return list.join('.');
+};
+
+exports.isClientId = (str) => {
+  if (!str || typeof str !== 'string') {
+    return false;
+  }
+  return str.length <= MAX_CLIENT_ID_LEN;
+};
+
+exports.getClientId = (ctx) => {
+  const clientId = ctx.get('x-whistle-nohost-client-id')
+    || ctx.get('x-whistle-client-id');
+  if (clientId && typeof clientId === 'string') {
+    return (clientId.trim() || ctx.ip).substring(0, MAX_CLIENT_ID_LEN);
+  }
+  return ctx.ip;
+};
+
+exports.changeFilter = (req, followerIp) => {
+  if (!req.url.indexOf('/cgi-bin/get-data?') && req.url.indexOf('ip=self') !== -1) {
+    followerIp = followerIp ? `,${followerIp}` : '';
+    req.url = req.url.replace('ip=self', `ip=clientId${followerIp}`);
+  }
+};
+
+exports.getNohostPluginsPath = () => {
+  return path.join(getWhistlePath(), 'nohost_plugins');
+};