whistle.script 1.2.1

package/lib/server.js

@@ -0,0 +1,32 @@
+const iconv = require('iconv-lite');
+const scripts = require('./scripts');
+const setupWsServer = require('./wsServer');
+const util = require('./util');
+
+module.exports = (server, options) => {
+  server.on('request', async (req, res) => {
+    if (util.isRemote(req)) {
+      return req.passThrough();
+    }
+    const ctx = util.getContext(req, res);
+    ctx.getStreamBuffer = util.getStreamBuffer;
+    ctx.getCharset = util.getCharset;
+    ctx.isText = util.isText;
+    ctx.iconv = iconv;
+    ctx.options = options;
+    const { handleRequest } = scripts.getHandler(ctx);
+    if (!util.isFunction(handleRequest)) {
+      return req.passThrough();
+    }
+    const { dataSource, clearup } = util.getDataSource();
+    ctx.dataSource = dataSource;
+    try {
+      await handleRequest(ctx, req.request);
+    } catch (err) {
+      clearup();
+      req.emit('error', err);
+      console.error(err); // eslint-disable-line
+    }
+  });
+  setupWsServer(server, options);
+};

package/lib/tunnelRulesServer.js

@@ -0,0 +1,24 @@
+const Koa = require('koa');
+const util = require('./util');
+const scripts = require('./scripts');
+
+module.exports = (server, options) => {
+  const app = new Koa();
+  app.use(async (ctx) => {
+    const { req } = ctx;
+    if (util.isRemote(req)) {
+      const rulesUrl = util.getRemoteUrl(req, util.REQ_RULES_URL);
+      if (rulesUrl) {
+        ctx.body = await util.request(rulesUrl, req.headers);
+      }
+      return;
+    }
+    util.setupContext(ctx, options);
+    const { handleTunnelRules } = scripts.getHandler(ctx);
+    if (util.isFunction(handleTunnelRules)) {
+      await handleTunnelRules(ctx);
+      util.responseRules(ctx);
+    }
+  });
+  server.on('request', app.callback());
+};

package/lib/tunnelServer.js

@@ -0,0 +1,37 @@
+const util = require('./util');
+const scripts = require('./scripts');
+/* eslint-disable no-empty */
+
+module.exports = (server, options) => {
+  server.on('connect', async (req, socket) => {
+    if (util.isRemote(req)) {
+      return req.passThrough();
+    }
+    const { url, headers } = req;
+    socket.headers = headers;
+    socket.options = options;
+    socket.req = req;
+    socket.originalReq = req.originalReq;
+    socket.url = socket.fullUrl = req.originalReq.url; // eslint-disable-line
+    const { handleTunnel } = scripts.getHandler(socket);
+    if (!util.isFunction(handleTunnel)) {
+      return req.passThrough();
+    }
+    const { dataSource, clearup } = util.getDataSource();
+    socket.dataSource = dataSource;
+    socket.url = url;
+    socket.on('error', clearup);
+    socket.on('close', clearup);
+    const connect = (opts) => {
+      return new Promise((resolve, reject) => {
+        const client = req.connect(opts, resolve) || req;
+        client.on('error', reject);
+      });
+    };
+    try {
+      await handleTunnel(socket, connect);
+    } catch (err) {
+      socket.emit('error', err);
+    }
+  });
+};

package/lib/uiServer/cgi-bin/create.js

@@ -0,0 +1,9 @@
+
+module.exports = (ctx) => {
+  const { name, value } = ctx.request.body;
+  if (name && typeof name === 'string') {
+    ctx.storage.writeFile(name, value);
+    ctx.scripts.set(name, value);
+  }
+  ctx.body = { ec: 0 };
+};

package/lib/uiServer/cgi-bin/delete.js

@@ -0,0 +1,9 @@
+
+module.exports = (ctx) => {
+  const { name } = ctx.request.body;
+  if (name && typeof name === 'string') {
+    ctx.storage.removeFile(name);
+    ctx.scripts.remove(name);
+  }
+  ctx.body = { ec: 0 };
+};

package/lib/uiServer/cgi-bin/emitData.js

@@ -0,0 +1,14 @@
+/* eslint-disable no-empty */
+module.exports = (ctx) => {
+  let { type, args } = ctx.request.body;
+  if (args && type && typeof type === 'string') {
+    try {
+      args = JSON.parse(args);
+      if (Array.isArray(args)) {
+        const { dataSource } = ctx;
+        dataSource.emit('data', type, args);
+      }
+    } catch (e) {}
+  }
+  ctx.body = { ec: 0 };
+};

package/lib/uiServer/cgi-bin/init.js

@@ -0,0 +1,10 @@
+
+module.exports = (ctx) => {
+  const { storage } = ctx;
+  /* eslint-disable prefer-arrow-callback */
+  ctx.body = {
+    list: storage.getFileList().map((item) => {
+      return { name: item.name, value: item.data };
+    }),
+  };
+};

package/lib/uiServer/cgi-bin/log.js

@@ -0,0 +1,4 @@
+
+module.exports = (ctx) => {
+  ctx.body = ctx.getLogs(ctx.request.query.id);
+};

package/lib/uiServer/cgi-bin/rename.js

@@ -0,0 +1,10 @@
+
+module.exports = (ctx) => {
+  const { name, newName } = ctx.request.body;
+  if (name && newName) {
+    ctx.storage.renameFile(name, newName);
+    ctx.scripts.set(newName, ctx.scripts.get(name));
+    ctx.scripts.remove(name);
+  }
+  ctx.body = { ec: 0 };
+};

package/lib/uiServer/index.js

@@ -0,0 +1,29 @@
+const Koa = require('koa');
+const onerror = require('koa-onerror');
+const bodyParser = require('koa-bodyparser');
+const serve = require('koa-static');
+const path = require('path');
+const router = require('koa-router')();
+const setupRouter = require('./router');
+const logger = require('../logger');
+const scripts = require('../scripts');
+const dataSource = require('../dataSource');
+
+module.exports = function (server, options) {
+  scripts.load(options.storage);
+  const app = new Koa();
+  onerror(app);
+  app.use(async (ctx, next) => {
+    ctx.storage = options.storage;
+    ctx.getLogs = logger.getLogs;
+    ctx.scripts = scripts;
+    ctx.dataSource = dataSource;
+    await next();
+  });
+  app.use(bodyParser());
+  setupRouter(router);
+  app.use(router.routes());
+  app.use(router.allowedMethods());
+  app.use(serve(path.join(__dirname, '../../public')));
+  server.on('request', app.callback());
+};

package/lib/uiServer/router.js

@@ -0,0 +1,15 @@
+const init = require('./cgi-bin/init');
+const log = require('./cgi-bin/log');
+const create = require('./cgi-bin/create');
+const rename = require('./cgi-bin/rename');
+const del = require('./cgi-bin/delete');
+const emitData = require('./cgi-bin/emitData');
+
+module.exports = (router) => {
+  router.get('/cgi-bin/init', init);
+  router.get('/cgi-bin/log', log);
+  router.post('/cgi-bin/create', create);
+  router.post('/cgi-bin/rename', rename);
+  router.post('/cgi-bin/delete', del);
+  router.post('/cgi-bin/emitData', emitData);
+};

package/lib/util.js

@@ -0,0 +1,192 @@
+const zlib = require('zlib');
+const { EventEmitter } = require('events');
+const { parse: parseUrl } = require('url');
+const http = require('http');
+const dataSource = require('./dataSource');
+
+exports.AUTH_URL = 'x-whistle-.script-auth-url';
+exports.REQ_RULES_URL = 'x-whistle-.script-req-rules-url';
+exports.RES_RULES_URL = 'x-whistle-.script-res-rules-url';
+exports.STATS_URL = 'x-whistle-.script-stats-url';
+exports.DATA_URL = 'x-whistle-.script-data-url';
+exports.noop = () => {};
+
+const POLICY = 'x-whistle-.script-policy';
+const isFunction = fn => typeof fn === 'function';
+const URL_RE = /^http:(?:\/\/|%3A%2F%2F)[\w.-]/;
+
+exports.isFunction = isFunction;
+exports.noop = () => {};
+const getCharset = (headers) => {
+  if (/charset=([^\s]+)/.test(headers['content-type'])) {
+    return RegExp.$1;
+  }
+  return 'utf8';
+};
+exports.getCharset = getCharset;
+exports.isText = (headers) => {
+  const type = headers['content-type'];
+  return !type || /javascript|css|html|json|xml|application\/x-www-form-urlencoded|text\//i.test(type);
+};
+
+const unzipBody = (headers, body, callback) => {
+  let unzip;
+  let encoding = headers['content-encoding'];
+  if (body && typeof encoding === 'string') {
+    encoding = encoding.trim().toLowerCase();
+    if (encoding === 'gzip') {
+      unzip = zlib.gunzip.bind(zlib);
+    } else if (encoding === 'deflate') {
+      unzip = zlib.inflate.bind(zlib);
+    }
+  }
+  if (!unzip) {
+    return callback(null, body);
+  }
+  unzip(body, (err, data) => {
+    if (err) {
+      return zlib.inflateRaw(body, callback);
+    }
+    callback(null, data);
+  });
+};
+
+exports.getStreamBuffer = (stream) => {
+  return new Promise((resolve, reject) => {
+    let buffer;
+    stream.on('data', (data) => {
+      buffer = buffer ? Buffer.concat([buffer, data]) : data;
+    });
+    stream.on('end', () => {
+      unzipBody(stream.headers, buffer, (err, data) => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve(data || null);
+        }
+      });
+    });
+    stream.on('error', reject);
+  });
+};
+
+exports.setupContext = (ctx, options) => {
+  ctx.options = options;
+  ctx.fullUrl = ctx.req.originalReq.url;
+};
+
+const formateRules = (ctx) => {
+  if (ctx.rules || ctx.values) {
+    return {
+      rules: Array.isArray(ctx.rules) ? ctx.rules.join('\n') : `${ctx.rules}`,
+      values: ctx.values,
+    };
+  }
+};
+
+exports.formateRules = formateRules;
+
+exports.responseRules = (ctx) => {
+  if (!ctx.body) {
+    ctx.body = formateRules(ctx);
+  }
+};
+
+exports.getDataSource = () => {
+  const ds = new EventEmitter();
+  const handleData = (type, args) => {
+    ds.emit(type, ...args);
+  };
+  dataSource.on('data', handleData);
+  return {
+    dataSource: ds,
+    clearup: () => {
+      dataSource.removeListener('data', handleData);
+      ds.removeAllListeners();
+    },
+  };
+};
+
+exports.getContext = (req, res) => {
+  const fullUrl = req.originalReq.url;
+  return {
+    req,
+    res,
+    fullUrl,
+    url: fullUrl,
+    headers: req.headers,
+    method: req.method,
+  };
+};
+
+exports.getFn = (f1, f2) => {
+  if (isFunction(f1)) {
+    return f1;
+  } if (isFunction(f2)) {
+    return f2;
+  }
+};
+
+
+const request = (url, headers, data) => {
+  if (!url) {
+    return;
+  }
+  const options = parseUrl(url);
+  options.headers = Object.assign({}, headers);
+  delete options.headers.host;
+  if (data) {
+    data = Buffer.from(JSON.stringify(data));
+    options.method = 'POST';
+  }
+  return new Promise((resolve, reject) => {
+    const client = http.request(options, (res) => {
+      res.on('error', handleError);  // eslint-disable-line
+      let body;
+      res.on('data', (chunk) => {
+        body = body ? Buffer.concat([body, chunk]) : chunk;
+      });
+      res.on('end', () => {
+        clearTimeout(timer); // eslint-disable-line
+        if (body) {
+          try {
+            resolve(JSON.parse(body.toString()) || '');
+          } catch (e) {}
+        }
+        resolve('');
+      });
+    });
+    const handleError = (err) => {
+      clearTimeout(timer);  // eslint-disable-line
+      client.destroy();
+      reject(err);
+    };
+    const timer = setTimeout(() => handleError(new Error('Timeout')), 12000);
+    client.on('error', handleError);
+    client.end(data);
+  });
+};
+
+exports.request = async (url, headers, data) => {
+  try {
+    return await request(url, headers, data);
+  } catch (e) {
+    if (!data) {
+      return request(url, headers, data);
+    }
+  }
+};
+
+const isRemote = ({ headers }) => (headers[POLICY] === 'remote');
+
+exports.isRemote = isRemote;
+
+exports.getRemoteUrl = (req, name) => {
+  let url = req.headers[name];
+  if (typeof url === 'string') {
+    url = decodeURIComponent(url);
+    if (URL_RE.test(url)) {
+      return url;
+    }
+  }
+};

package/lib/wsServer.js

@@ -0,0 +1,107 @@
+const crypto = require('crypto');
+const iconv = require('iconv-lite');
+const { getDataSource, getFn } = require('./util');
+const scripts = require('./scripts');
+
+
+module.exports = (server, options) => {
+  const { getReceiver, getSender } = options.wsParser;
+
+  const wrap = (socket, receiver, sender) => {
+    socket.on('data', receiver.add.bind(receiver));
+    receiver.onData = (data, opts) => socket.emit('message', data, opts);
+    receiver.onping = (data) => socket.emit('ping', data);
+    receiver.onpong = (data) => socket.emit('pong', data);
+    receiver.onclose = (code, message, opts) => socket.emit('disconnect', code, message, opts);
+    receiver.onerror = (reason, code) => {
+      const err = new Error(reason);
+      err.code = code;
+      socket.emit('error', err);
+    };
+    socket.send = sender.send.bind(sender);
+    socket.ping = sender.ping.bind(sender);
+    socket.pong = sender.pong.bind(sender);
+    socket.disconnect = sender.close.bind(sender);
+  };
+
+  const wrapServerSocket = (socket) => {
+    const receiver = getReceiver(socket, true);
+    const sender = getSender(socket);
+    wrap(socket, receiver, sender);
+  };
+
+  const wrapClientSocket = (socket) => {
+    const receiver = getReceiver(socket);
+    const sender = getSender(socket, true);
+    wrap(socket, receiver, sender);
+  };
+
+  server.on('upgrade', async (req, socket) => {
+    const oReq = req.originalReq;
+    socket.options = options;
+    socket.req = req;
+    socket.originalReq = oReq;
+    const {
+      handleWebsocket,
+      handleWebSocket,
+    } = scripts.getHandler(socket);
+    const handleRequest = getFn(handleWebSocket, handleWebsocket);
+    if (!handleRequest) {
+      return req.passThrough();
+    }
+    const { dataSource, clearup } = getDataSource();
+    const { headers } = req;
+    let replied;
+    req.on('error', clearup);
+    socket.dataSource = dataSource;
+    socket.headers = headers;
+    socket.iconv = iconv;
+    socket.url = socket.fullUrl = oReq.url; // eslint-disable-line
+    const handleUpgrade = (res) => {
+      if (replied) {
+        return;
+      }
+      replied = true;
+      let key = `${headers['sec-websocket-key']}258EAFA5-E914-47DA-95CA-C5AB0DC85B11`;
+      key = crypto.createHash('sha1').update(key, 'binary').digest('base64');
+      if (res) {
+        if (res.statusCode == 101) { // eslint-disable-line
+          res.headers['sec-websocket-accept'] = key;
+        }
+      } else {
+        const protocol = (headers['sec-websocket-protocol'] || '').split(/, */)[0];
+        res = {
+          statusCode: 101,
+          headers: {
+            'Sec-WebSocket-Accept': key,
+            Upgrade: 'websocket',
+            Connection: 'Upgrade',
+          },
+        };
+        if (protocol) {
+          res.headers['Sec-WebSocket-Protocol'] = protocol;
+        }
+      }
+      req.writeHead(res.statusCode, res.statusMessage, res.headers);
+    };
+    const connect = opts => new Promise((resolve, reject) => {
+      const client = req.request(opts, (svrRes) => {
+        handleUpgrade(svrRes);
+        wrapClientSocket(svrRes);
+        resolve(svrRes);
+      }, true) || req;
+      client.on('error', reject);
+    });
+    try {
+      wrapServerSocket(socket);
+      await handleRequest(socket, connect);
+      handleUpgrade();
+    } catch (err) {
+      clearup();
+      // 这么写才能在 Network 的 body 里面显示内容
+      const body = String(err.stack || '');
+      const length = Buffer.byteLength(body);
+      socket.write(`HTTP/1.1 502 Bad Gateway\r\nServer: whistle.script\r\nContent-length: ${length}\r\n\r\n${body}`);
+    }
+  });
+};

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "whistle.script",
+  "description": "The plugin for the extension script for whistle",
+  "version": "1.2.1",
+  "author": "avenwu <avenwu@vip.qq.com>",
+  "contributors": [],
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/whistle-plugins/whistle.script/issues"
+  },
+  "homepage": "https://github.com/whistle-plugins/whistle.script",
+  "keywords": [
+    "whistle",
+    "proxy",
+    "ssi"
+  ],
+  "registry": "https://github.com/whistle-plugins/whistle.script",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/whistle-plugins/whistle.script.git"
+  },
+  "scripts": {
+    "dev": "webpack --config ./src/webpack.config.js -w",
+    "lint": "eslint ./lib test index.js",
+    "lintfix": "eslint --fix ./lib test index.js"
+  },
+  "devDependencies": {
+    "babel-core": "^6.7.6",
+    "babel-eslint": "^8.2.6",
+    "babel-loader": "^6.2.4",
+    "babel-preset-react": "^6.5.0",
+    "bootstrap": "^3.3.6",
+    "clipboard": "^1.5.8",
+    "codemirror": "^5.11.0",
+    "css-loader": "^0.28.11",
+    "eslint": "^5.4.0",
+    "eslint-config-imweb": "^0.2.11",
+    "file-loader": "^0.8.5",
+    "jquery": "^3.3.1",
+    "jsx-loader": "^0.13.2",
+    "react": "^15.4.2",
+    "react-dom": "^15.4.2",
+    "style-loader": "^0.23.1",
+    "url-loader": "0.5.6",
+    "webpack": "^1.14.0"
+  },
+  "dependencies": {
+    "iconv-lite": "^0.4.24",
+    "koa": "^2.13.1",
+    "koa-bodyparser": "^4.3.0",
+    "koa-onerror": "^4.1.0",
+    "koa-router": "^10.0.0",
+    "koa-static": "^5.0.0"
+  }
+}

package/public/index.html

@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="UTF-8">
+<meta name="google" value="notranslate">
+<title>Whistle Script</title>
+</head>
+<body>
+<div id="main" class="main"></div>
+<script src="index.js?v=0.4.0"></script>
+</body>
+</html>