@yvhitxcel/opencode-remote 0.15.0

package/dist/weixin/node_modules/qiniu/qiniu/util.js

@@ -0,0 +1,382 @@
+const url = require('url');
+const crypto = require('crypto');
+
+// Check Timestamp Expired or not
+exports.isTimestampExpired = function (timestamp) {
+    return timestamp < Math.trunc(Date.now() / 1000);
+};
+
+// Format Data
+exports.formatDateUTC = function (date, layout) {
+    function pad (num, digit) {
+        const d = digit || 2;
+        let result = num.toString();
+        while (result.length < d) {
+            result = '0' + result;
+        }
+        return result;
+    }
+
+    const d = new Date(date);
+    const year = d.getUTCFullYear();
+    const month = d.getUTCMonth() + 1;
+    const day = d.getUTCDate();
+    const hour = d.getUTCHours();
+    const minute = d.getUTCMinutes();
+    const second = d.getUTCSeconds();
+    const millisecond = d.getUTCMilliseconds();
+
+    let result = layout || 'YYYY-MM-DDTHH:MM:ss.SSSZ';
+
+    result = result.replace(/YYYY/g, year.toString())
+        .replace(/MM/g, pad(month))
+        .replace(/DD/g, pad(day))
+        .replace(/HH/g, pad(hour))
+        .replace(/mm/g, pad(minute))
+        .replace(/ss/g, pad(second))
+        .replace(/SSS/g, pad(millisecond, 3));
+
+    return result;
+};
+
+// Encoded Entry
+exports.encodedEntry = function (bucket, key) {
+    let strToEncode = bucket;
+    if (key !== undefined) {
+        strToEncode += ':' + key;
+    }
+    return exports.urlsafeBase64Encode(strToEncode);
+};
+
+exports.decodedEntry = function (entry) {
+    const [bucket, key] = exports.urlSafeBase64Decode(entry).split(':');
+    return [bucket, key];
+};
+
+// Get accessKey from uptoken
+exports.getAKFromUptoken = function (uploadToken) {
+    var sepIndex = uploadToken.indexOf(':');
+    return uploadToken.substring(0, sepIndex);
+};
+
+// Get bucket from uptoken
+exports.getBucketFromUptoken = function (uploadToken) {
+    var sepIndex = uploadToken.lastIndexOf(':');
+    var encodedPutPolicy = uploadToken.substring(sepIndex + 1);
+    var putPolicy = exports.urlSafeBase64Decode(encodedPutPolicy);
+    var putPolicyObj = JSON.parse(putPolicy);
+    var scope = putPolicyObj.scope;
+    var scopeSepIndex = scope.indexOf(':');
+    if (scopeSepIndex == -1) {
+        return scope;
+    } else {
+        return scope.substring(0, scopeSepIndex);
+    }
+};
+
+exports.base64ToUrlSafe = function (v) {
+    return v.replace(/\//g, '_').replace(/\+/g, '-');
+};
+
+exports.urlSafeToBase64 = function (v) {
+    return v.replace(/_/g, '/').replace(/-/g, '+');
+};
+
+// UrlSafe Base64 Decode
+exports.urlsafeBase64Encode = function (jsonFlags) {
+    var encoded = Buffer.from(jsonFlags).toString('base64');
+    return exports.base64ToUrlSafe(encoded);
+};
+
+// UrlSafe Base64 Decode
+exports.urlSafeBase64Decode = function (fromStr) {
+    return Buffer.from(exports.urlSafeToBase64(fromStr), 'base64').toString();
+};
+
+// Hmac-sha1 Crypt
+exports.hmacSha1 = function (encodedFlags, secretKey) {
+    /*
+   *return value already encoded with base64
+   * */
+    var hmac = crypto.createHmac('sha1', secretKey);
+    hmac.update(encodedFlags);
+    return hmac.digest('base64');
+};
+
+// get md5
+exports.getMd5 = function (data) {
+    var md5 = crypto.createHash('md5');
+    return md5.update(data).digest('hex');
+};
+
+// 创建 AccessToken 凭证
+// @param mac         AK&SK对象
+// @param requestURI 请求URL
+// @param reqBody    请求Body，仅当请求的 ContentType 为
+//                   application/x-www-form-urlencoded时才需要传入该参数
+exports.generateAccessToken = function (mac, requestURI, reqBody) {
+    const u = new url.URL(requestURI);
+    const path = u.pathname + u.search;
+    let access = path + '\n';
+
+    if (reqBody) {
+        access += reqBody;
+    }
+
+    const digest = exports.hmacSha1(access, mac.secretKey);
+    const safeDigest = exports.base64ToUrlSafe(digest);
+    return 'QBox ' + mac.accessKey + ':' + safeDigest;
+};
+
+const isTokenTable = {
+    '!': true,
+    '#': true,
+    $: true,
+    '%': true,
+    '&': true,
+    '\\': true,
+    '*': true,
+    '+': true,
+    '-': true,
+    '.': true,
+    0: true,
+    1: true,
+    2: true,
+    3: true,
+    4: true,
+    5: true,
+    6: true,
+    7: true,
+    8: true,
+    9: true,
+    A: true,
+    B: true,
+    C: true,
+    D: true,
+    E: true,
+    F: true,
+    G: true,
+    H: true,
+    I: true,
+    J: true,
+    K: true,
+    L: true,
+    M: true,
+    N: true,
+    O: true,
+    P: true,
+    Q: true,
+    R: true,
+    S: true,
+    T: true,
+    U: true,
+    W: true,
+    V: true,
+    X: true,
+    Y: true,
+    Z: true,
+    '^': true,
+    _: true,
+    '`': true,
+    a: true,
+    b: true,
+    c: true,
+    d: true,
+    e: true,
+    f: true,
+    g: true,
+    h: true,
+    i: true,
+    j: true,
+    k: true,
+    l: true,
+    m: true,
+    n: true,
+    o: true,
+    p: true,
+    q: true,
+    r: true,
+    s: true,
+    t: true,
+    u: true,
+    v: true,
+    w: true,
+    x: true,
+    y: true,
+    z: true,
+    '|': true,
+    '~': true
+};
+/**
+ * 是否合法的 header field name 字符
+ * @param ch string
+ * @returns boolean|undefined
+ */
+function validHeaderKeyChar (ch) {
+    if (ch.charCodeAt(0) >= 128) {
+        return false;
+    }
+    return isTokenTable[ch];
+}
+
+/**
+ * 规范化 header field name
+ * @param fieldName string
+ * @returns string
+ */
+exports.canonicalMimeHeaderKey = function (fieldName) {
+    for (const ch of fieldName) {
+        if (!validHeaderKeyChar(ch)) {
+            return fieldName;
+        }
+    }
+    return fieldName.split('-')
+        .map(function (text) {
+            return text.substring(0, 1).toUpperCase() + text.substring(1).toLowerCase();
+        })
+        .join('-');
+};
+
+/**
+ * 创建 AccessToken 凭证
+ * @param {Mac} mac AK&SK对象
+ * @param {string} requestURI 请求URL
+ * @param {string} reqMethod 请求方法，例如 GET，POST
+ * @param {string} reqContentType 请求类型，例如 application/json 或者  application/x-www-form-urlencoded
+ * @param {string | Buffer} reqBody 请求Body，仅当请求的 ContentType 为 application/json 或者
+ * application/x-www-form-urlencoded 时才需要传入该参数
+ * @param {Object.<string, string>} reqHeaders 请求头部
+ */
+exports.generateAccessTokenV2 = function (mac, requestURI, reqMethod, reqContentType, reqBody, reqHeaders) {
+    const u = new url.URL(requestURI);
+    const path = u.pathname;
+    const search = u.search;
+    const host = u.host;
+    const port = u.port;
+
+    let access = reqMethod.toUpperCase() + ' ' + path;
+    if (search) {
+        access += search;
+    }
+    // add host
+    access += '\nHost: ' + host;
+    // add port
+    if (port) {
+        access += ':' + port;
+    }
+
+    // add content type
+    if (reqContentType) {
+        access += '\nContent-Type: ' + reqContentType;
+    } else {
+        access += '\nContent-Type: application/x-www-form-urlencoded';
+    }
+
+    // add headers
+    if (reqHeaders) {
+        const canonicalHeaders = Object.keys(reqHeaders)
+            .reduce(function (acc, k) {
+                acc[exports.canonicalMimeHeaderKey(k)] = reqHeaders[k];
+                return acc;
+            }, {});
+        const headerText = Object.keys(canonicalHeaders)
+            .filter(function (k) {
+                return k.startsWith('X-Qiniu-') && k.length > 'X-Qiniu-'.length;
+            })
+            .sort()
+            .map(function (k) {
+                return k + ': ' + canonicalHeaders[k];
+            })
+            .join('\n');
+        if (headerText) {
+            access += '\n' + headerText;
+        }
+    }
+
+    access += '\n\n';
+
+    // add reqbody
+    if (reqBody && reqContentType !== 'application/octet-stream') {
+        access += reqBody;
+    }
+
+    const digest = exports.hmacSha1(access, mac.secretKey);
+    const safeDigest = exports.base64ToUrlSafe(digest);
+    return 'Qiniu ' + mac.accessKey + ':' + safeDigest;
+};
+
+// 校验七牛上传回调的Authorization
+// @param mac           AK&SK对象
+// @param requestURI   回调的URL中的requestURI
+// @param reqBody      请求Body，仅当请求的ContentType为
+//                     application/x-www-form-urlencoded时才需要传入该参数
+// @param callbackAuth 回调时请求的Authorization头部值
+
+/**
+ * @param {Mac} mac AK&SK对象
+ * @param {string} requestURI 请求URL
+ * @param {string | Buffer} reqBody 请求Body，仅当请求的 ContentType 为 application/json 或 application/x-www-form-urlencoded 时才需要传入该参数
+ * @param {string} callbackAuth 回调时请求的 Authorization 头部值
+ * @param {Object} [extra] 当回调为 Qiniu 签名时需要传入
+ * @param {string} extra.reqMethod 请求方法，例如 GET，POST
+ * @param {string} [extra.reqContentType] 请求类型，例如 application/json 或者  application/x-www-form-urlencoded
+ * @param {Object.<string, string>} [extra.reqHeaders] 请求头部
+ * @return {boolean}
+ */
+exports.isQiniuCallback = function (
+    mac,
+    requestURI,
+    reqBody,
+    callbackAuth,
+    extra
+) {
+    let auth;
+    if (callbackAuth.startsWith('Qiniu')) {
+        auth = exports.generateAccessTokenV2(
+            mac,
+            requestURI,
+            extra.reqMethod,
+            extra.reqContentType,
+            reqBody,
+            extra.reqHeaders
+        );
+    } else {
+        auth = exports.generateAccessToken(mac, requestURI, reqBody);
+    }
+
+    return auth === callbackAuth;
+};
+
+/**
+ * @deprecated use Config.prototype.getRegionsProvider instead
+ */
+exports.prepareZone = function (ctx, accessKey, bucket, callback) {
+    // resolve cycle dependency by require dynamically
+    const zone = require('./zone');
+    var useCache = false;
+    if (ctx.config.zone !== '' && ctx.config.zone != null) {
+        if (ctx.config.zoneExpire === -1) {
+            useCache = true;
+        } else {
+            if (!exports.isTimestampExpired(ctx.config.zoneExpire)) {
+                useCache = true;
+            }
+        }
+    }
+
+    if (useCache) {
+        callback(null, ctx);
+    } else {
+        zone.getZoneInfo(accessKey, bucket, function (err, cZoneInfo,
+            cZoneExpire) {
+            if (err) {
+                callback(err);
+                return;
+            }
+            // update object
+            ctx.config.zone = cZoneInfo;
+            ctx.config.zoneExpire = cZoneExpire + Math.trunc(Date.now() / 1000);
+            callback(null, ctx);
+        });
+    }
+};

package/dist/weixin/node_modules/qiniu/qiniu/zone.js

@@ -0,0 +1,230 @@
+const rpc = require('./rpc');
+const { RetryDomainsMiddleware } = require('./httpc/middleware');
+
+/**
+ * @deprecated use qiniu/httpc/region.js instead
+ * @param {string[]} srcUpHosts
+ * @param {string[]} cdnUpHosts
+ * @param {string} ioHost
+ * @param {string} rsHost
+ * @param {string} rsfHost
+ * @param {string} apiHost
+ * @constructor
+ */
+function Zone (
+    srcUpHosts,
+    cdnUpHosts,
+    ioHost,
+    rsHost,
+    rsfHost,
+    apiHost
+) {
+    this.srcUpHosts = srcUpHosts || [];
+    this.cdnUpHosts = cdnUpHosts || [];
+    this.ioHost = ioHost || '';
+    this.rsHost = rsHost;
+    this.rsfHost = rsfHost;
+    this.apiHost = apiHost;
+
+    // set specific hosts if possible
+    const dotIndex = this.ioHost.indexOf('.');
+    if (dotIndex !== -1) {
+        const ioTag = this.ioHost.substring(0, dotIndex);
+        const zoneSepIndex = ioTag.indexOf('-');
+        if (zoneSepIndex !== -1) {
+            const zoneTag = ioTag.substring(zoneSepIndex + 1);
+            switch (zoneTag) {
+            case 'z1':
+                !this.rsHost && (this.rsHost = 'rs-z1.qbox.me');
+                !this.rsfHost && (this.rsfHost = 'rsf-z1.qbox.me');
+                !this.apiHost && (this.apiHost = 'api-z1.qiniuapi.com');
+                break;
+            case 'z2':
+                !this.rsHost && (this.rsHost = 'rs-z2.qbox.me');
+                !this.rsfHost && (this.rsfHost = 'rsf-z2.qbox.me');
+                !this.apiHost && (this.apiHost = 'api-z2.qiniuapi.com');
+                break;
+            case 'na0':
+                !this.rsHost && (this.rsHost = 'rs-na0.qbox.me');
+                !this.rsfHost && (this.rsfHost = 'rsf-na0.qbox.me');
+                !this.apiHost && (this.apiHost = 'api-na0.qiniuapi.com');
+                break;
+            case 'as0':
+                !this.rsHost && (this.rsHost = 'rs-as0.qbox.me');
+                !this.rsfHost && (this.rsfHost = 'rsf-as0.qbox.me');
+                !this.apiHost && (this.apiHost = 'api-as0.qiniuapi.com');
+                break;
+            }
+        }
+    }
+
+    !this.rsHost && (this.rsHost = 'rs.qiniu.com');
+    !this.rsfHost && (this.rsfHost = 'rsf.qiniu.com');
+    !this.apiHost && (this.apiHost = 'api.qiniuapi.com');
+}
+
+exports.Zone = Zone;
+
+/**
+ * huadong
+ * @type {Zone}
+ * @deprecated use Region.fromRegionId('z0') instead
+ */
+exports.Zone_z0 = new Zone([
+    'up.qiniup.com'
+], [
+    'upload.qiniup.com'
+], 'iovip.qbox.me',
+'rs.qbox.me',
+'rsf.qbox.me',
+'api.qiniuapi.com');
+
+/**
+ * huadong2
+ * @type {Zone}
+ * @deprecated use Region.fromRegionId('cn-east-2') instead
+ */
+exports.Zone_cn_east_2 = new Zone([
+    'up-cn-east-2.qiniup.com'
+], [
+    'upload-cn-east-2.qiniup.com'
+], 'iovip-cn-east-2.qiniuio.com',
+'rs-cn-east-2.qiniuapi.com',
+'rsf-cn-east-2.qiniuapi.com',
+'api-cn-east-2.qiniuapi.com');
+
+/**
+ * huabei
+ * @type {Zone}
+ * @deprecated use Region.fromRegionId('z1') instead
+ */
+exports.Zone_z1 = new Zone([
+    'up-z1.qiniup.com'
+], [
+    'upload-z1.qiniup.com'
+], 'iovip-z1.qbox.me',
+'rs-z1.qbox.me',
+'rsf-z1.qbox.me',
+'api-z1.qiniuapi.com');
+
+/**
+ * huanan
+ * @type {Zone}
+ * @deprecated use Region.fromRegionId('z2') instead
+ */
+exports.Zone_z2 = new Zone([
+    'up-z2.qiniup.com'
+], [
+    'upload-z2.qiniup.com'
+], 'iovip-z2.qbox.me',
+'rs-z2.qbox.me',
+'rsf-z2.qbox.me',
+'api-z2.qiniuapi.com');
+
+/**
+ * beimei
+ * @type {Zone}
+ * @deprecated use Region.fromRegionId('na0') instead
+ */
+exports.Zone_na0 = new Zone([
+    'up-na0.qiniup.com'
+], [
+    'upload-na0.qiniup.com'
+], 'iovip-na0.qbox.me',
+'rs-na0.qbox.me',
+'rsf-na0.qbox.me',
+'api-na0.qiniuapi.com');
+
+/**
+ * singapore
+ * @type {Zone}
+ * @deprecated use Region.fromRegionId('as0') instead
+ */
+exports.Zone_as0 = new Zone([
+    'up-as0.qiniup.com'
+], [
+    'upload-as0.qiniup.com'
+], 'iovip-as0.qbox.me',
+'rs-as0.qbox.me',
+'rsf-as0.qbox.me',
+'api-as0.qiniuapi.com');
+
+/**
+ * @deprecated use QueryRegionsProvider instead
+ * @param {string} accessKey
+ * @param {string} bucket
+ * @param {function(Error | null, any, any)} callbackFunc
+ */
+exports.getZoneInfo = function (accessKey, bucket, callbackFunc) {
+    // resolve cycle dependency by require dynamically
+    const conf = require('./conf');
+    const apiAddr = 'https://' + conf.QUERY_REGION_HOST + '/v4/query';
+
+    rpc.qnHttpClient.get({
+        url: apiAddr,
+        params: {
+            ak: accessKey,
+            bucket: bucket
+        },
+        middlewares: [
+            new RetryDomainsMiddleware({
+                backupDomains: conf.QUERY_REGION_BACKUP_HOSTS
+            })
+        ],
+        callback: function (respErr, respData, respInfo) {
+            if (respErr) {
+                callbackFunc(respErr, null, null);
+                return;
+            }
+
+            if (respInfo.statusCode !== 200) {
+                // not ok
+                respErr = new Error(respInfo.statusCode + '\n' + respData);
+                callbackFunc(respErr, null, null);
+                return;
+            }
+
+            let zoneData;
+            try {
+                const hosts = respData.hosts;
+                if (!hosts || !hosts.length) {
+                    respErr = new Error('no host available: ' + respData);
+                    callbackFunc(respErr, null, null);
+                    return;
+                }
+                zoneData = hosts[0];
+            } catch (err) {
+                callbackFunc(err, null, null);
+                return;
+            }
+            let srcUpHosts = [];
+            let cdnUpHosts = [];
+            let zoneExpire = 0;
+
+            try {
+                zoneExpire = zoneData.ttl;
+                // read src hosts
+                srcUpHosts = zoneData.up.domains;
+
+                // read acc hosts
+                cdnUpHosts = zoneData.up.domains;
+
+                const ioHost = zoneData.io.domains[0];
+                const rsHost = zoneData.rs.domains[0];
+                const rsfHost = zoneData.rsf.domains[0];
+                const apiHost = zoneData.api.domains[0];
+                const zoneInfo = new Zone(
+                    srcUpHosts,
+                    cdnUpHosts,
+                    ioHost,
+                    rsHost,
+                    rsfHost,
+                    apiHost
+                );
+                callbackFunc(null, zoneInfo, zoneExpire);
+            } catch (e) {
+                callbackFunc(e, null, null);
+            }
+        }
+    });
+};