@yvhitxcel/opencode-remote 0.15.0

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

@@ -0,0 +1,254 @@
+const os = require('os');
+const pkg = require('../package.json');
+const { Endpoint } = require('./httpc/endpoint');
+const { Region } = require('./httpc/region');
+const { StaticEndpointsProvider } = require('./httpc/endpointsProvider');
+const crypto = require('crypto');
+const {
+    CachedRegionsProvider,
+    QueryRegionsProvider
+} = require('./httpc/regionsProvider');
+
+exports.ACCESS_KEY = '<PLEASE APPLY YOUR ACCESS KEY>';
+exports.SECRET_KEY = '<DONT SEND YOUR SECRET KEY TO ANYONE>';
+
+const defaultUserAgent = function () {
+    return 'QiniuNodejs/' + pkg.version + ' (' + os.type() + '; ' + os.platform() +
+        '; ' + os.arch() + '; )';
+};
+
+exports.USER_AGENT = defaultUserAgent();
+exports.BLOCK_SIZE = 4 * 1024 * 1024; // 4MB, never change
+
+// define api form mime type
+exports.FormMimeUrl = 'application/x-www-form-urlencoded';
+exports.FormMimeJson = 'application/json';
+exports.FormMimeRaw = 'application/octet-stream';
+exports.RS_HOST = 'rs.qiniu.com';
+exports.RPC_TIMEOUT = 600000; // 600s
+let QUERY_REGION_BACKUP_HOSTS = [
+    'kodo-config.qiniuapi.com',
+    'uc.qbox.me'
+];
+Object.defineProperty(exports, 'QUERY_REGION_BACKUP_HOSTS', {
+    get: () => QUERY_REGION_BACKUP_HOSTS,
+    set: v => {
+        QUERY_REGION_BACKUP_HOSTS = v;
+    }
+});
+let QUERY_REGION_HOST = 'uc.qiniuapi.com';
+Object.defineProperty(exports, 'QUERY_REGION_HOST', {
+    get: () => QUERY_REGION_HOST,
+    set: v => {
+        QUERY_REGION_HOST = v;
+        QUERY_REGION_BACKUP_HOSTS = [];
+    }
+});
+let UC_BACKUP_HOSTS = QUERY_REGION_BACKUP_HOSTS.slice();
+let UC_HOST = QUERY_REGION_HOST;
+Object.defineProperty(exports, 'UC_HOST', {
+    get: () => UC_HOST,
+    set: v => {
+        UC_HOST = v;
+        UC_BACKUP_HOSTS = [];
+        QUERY_REGION_HOST = v;
+        QUERY_REGION_BACKUP_HOSTS = [];
+    }
+});
+
+// proxy
+exports.RPC_HTTP_AGENT = null;
+exports.RPC_HTTPS_AGENT = null;
+
+const Config = (function () {
+    /**
+     * @class
+     * @constructor
+     * @param {Object} [options]
+     * @param {boolean} [options.useHttpsDomain]
+     * @param {boolean} [options.accelerateUploading] enable accelerate uploading. should active the domains in portal before using
+     * @param {EndpointsProvider} [options.ucEndpointsProvider]
+     * @param {EndpointsProvider} [options.queryRegionsEndpointsProvider]
+     * @param {RegionsProvider} [options.regionsProvider]
+     * @param {string} [options.regionsQueryResultCachePath]
+     *
+     * @param {boolean} [options.useCdnDomain] DEPRECATED: use accelerateUploading instead
+     * @param {Zone} [options.zone] DEPRECATED: use RegionsProvider instead
+     * @param {number} [options.zoneExpire] DEPRECATED
+     */
+    function Config (options) {
+        options = options || {};
+        // use http or https protocol
+        this.useHttpsDomain = !!(options.useHttpsDomain || false);
+
+        // use accelerate upload domains
+        this.accelerateUploading = !!(options.accelerateUploading || false);
+
+        // custom uc endpoints
+        this.ucEndpointsProvider = options.ucEndpointsProvider || null;
+        // custom query region endpoints
+        this.queryRegionsEndpointsProvider = options.queryRegionsEndpointsProvider || null;
+        // custom regions
+        this.regionsProvider = options.regionsProvider || null;
+        // custom cache persisting path for regions query result
+        // only worked with default CachedRegionsProvider
+        this.regionsQueryResultCachePath = options.regionsQueryResultCachePath;
+
+        // deprecated
+        // use cdn accelerated domains, this is not work with auto query region
+        this.useCdnDomain = !!(options.useCdnDomain && true);
+        // zone of the bucket
+        this.zone = options.zone || null;
+        this.zoneExpire = options.zoneExpire || -1;
+    }
+
+    /**
+     * @returns {EndpointsProvider}
+     */
+    Config.prototype.getUcEndpointsProvider = function () {
+        if (this.ucEndpointsProvider) {
+            return this.ucEndpointsProvider;
+        }
+
+        return new StaticEndpointsProvider(
+            [UC_HOST].concat(UC_BACKUP_HOSTS).map(h => new Endpoint(h, {
+                defaultScheme: this.useHttpsDomain ? 'https' : 'http'
+            }))
+        );
+    };
+
+    /**
+     * @private
+     * @returns {EndpointsProvider}
+     */
+    Config.prototype._getQueryRegionEndpointsProvider = function () {
+        if (this.queryRegionsEndpointsProvider) {
+            return this.queryRegionsEndpointsProvider;
+        }
+
+        if (this.ucEndpointsProvider) {
+            return this.ucEndpointsProvider;
+        }
+
+        const queryRegionsHosts = [QUERY_REGION_HOST].concat(QUERY_REGION_BACKUP_HOSTS);
+        return new StaticEndpointsProvider(queryRegionsHosts.map(h =>
+            new Endpoint(
+                h,
+                {
+                    defaultScheme: this.useHttpsDomain ? 'https' : 'http'
+                }
+            )
+        ));
+    };
+
+    /**
+     * @param {Object} [options]
+     * @param {string} [options.bucketName]
+     * @param {string} [options.accessKey]
+     * @returns {Promise<RegionsProvider>}
+     */
+    Config.prototype.getRegionsProvider = function (options) {
+        // returns custom regions provider, if it's configured
+        if (this.regionsProvider) {
+            return Promise.resolve(this.regionsProvider);
+        }
+
+        // backward compatibility with custom zone configuration
+        const zoneProvider = getRegionsProviderFromZone.call(this);
+        if (zoneProvider) {
+            return Promise.resolve(zoneProvider);
+        }
+
+        // get default regions provider
+        const {
+            bucketName,
+            accessKey
+        } = options || {};
+        if (!bucketName || !accessKey) {
+            return Promise.reject(
+                new Error('bucketName and accessKey is required for query regions')
+            );
+        }
+        return getDefaultRegionsProvider.call(this, {
+            bucketName,
+            accessKey
+        });
+    };
+
+    /**
+     * @private
+     * @returns {RegionsProvider | undefined}
+     */
+    function getRegionsProviderFromZone () {
+        let zoneTTL;
+        let shouldUseZone;
+        if (this.zoneExpire > 0) {
+            zoneTTL = this.zoneExpire - Math.trunc(Date.now() / 1000);
+            shouldUseZone = this.zone && zoneTTL > 0;
+        } else {
+            zoneTTL = -1;
+            shouldUseZone = Boolean(this.zone);
+        }
+        if (!shouldUseZone) {
+            return;
+        }
+        return Region.fromZone(this.zone, {
+            ttl: zoneTTL,
+            isPreferCdnHost: this.useCdnDomain,
+            preferredScheme: this.useHttpsDomain ? 'https' : 'http'
+        });
+    }
+
+    /**
+     * @private
+     * @param {Object} options
+     * @param {string} options.bucketName
+     * @param {string} options.accessKey
+     * @returns {Promise<RegionsProvider>}
+     */
+    function getDefaultRegionsProvider (options) {
+        const {
+            bucketName,
+            accessKey
+        } = options;
+
+        const queryRegionsEndpointsProvider = this._getQueryRegionEndpointsProvider();
+        return queryRegionsEndpointsProvider
+            .getEndpoints()
+            .then(endpoints => {
+                const endpointsMd5 = endpoints
+                    .map(e => e.host)
+                    .sort()
+                    .reduce(
+                        (hash, host) => hash.update(host),
+                        crypto.createHash('md5')
+                    )
+                    .digest('hex');
+                const cacheKey = [
+                    endpointsMd5,
+                    accessKey,
+                    bucketName,
+                    this.accelerateUploading.toString()
+                ].join(':');
+                return new CachedRegionsProvider({
+                    persistPath: this.regionsQueryResultCachePath,
+                    cacheKey,
+                    baseRegionsProvider: new QueryRegionsProvider({
+                        accessKey: accessKey,
+                        bucketName: bucketName,
+                        endpointsProvider: queryRegionsEndpointsProvider,
+                        preferredScheme: this.useHttpsDomain ? 'https' : 'http'
+                    })
+                });
+            });
+    }
+
+    return Config;
+})();
+
+exports.Config = Config;
+/**
+ * backward compatibility
+ * @deprecated use qiniu/httpc/region.js instead
+ */
+exports.Zone = require('./zone').Zone;

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

@@ -0,0 +1,112 @@
+const util = require('./util');
+const rpc = require('./rpc');
+const conf = require('./conf');
+const digest = require('./auth/digest');
+const querystring = require('querystring');
+
+exports.OperationManager = OperationManager;
+
+function OperationManager (mac, config) {
+    this.mac = mac || new digest.Mac();
+    this.config = config || new conf.Config();
+}
+
+/**
+ * @typedef {function(Error, any, IncomingMessage)} OperationCallback
+ */
+
+/**
+ * @param {string} bucket 空间名称
+ * @param {string} key 文件名称
+ * @param {string[]} fops 处理指令
+ * @param {string} [pipeline] 队列名称
+ * @param {object} options 可选参数
+ * @param {string} [options.notifyURL] 回调业务服务器，通知处理结果
+ * @param {boolean} [options.force] 是否强制覆盖已有的同名文件
+ * @param {string} [options.type] 为 `1` 时，开启闲时任务
+ * @param {string} [options.workflowTemplateID] 工作流模板 ID
+ * @param {OperationCallback} callbackFunc 回调函数
+ */
+OperationManager.prototype.pfop = function (
+    bucket,
+    key,
+    fops,
+    pipeline,
+    options,
+    callbackFunc
+) {
+    options = options || {};
+    // 必须参数
+    const reqParams = {
+        bucket: bucket,
+        key: key
+    };
+    // `fops` is optional by could use `options.workflowTemplateID` to work
+    if (Array.isArray(fops)) {
+        reqParams.fops = fops.join(';');
+    }
+
+    // pipeline
+    if (pipeline) {
+        reqParams.pipeline = pipeline;
+    }
+
+    // notifyURL
+    if (options.notifyURL) {
+        reqParams.notifyURL = options.notifyURL;
+    }
+
+    // force
+    if (options.force) {
+        reqParams.force = 1;
+    }
+
+    // workflowTemplateID
+    if (options.workflowTemplateID) {
+        reqParams.workflowTemplateID = options.workflowTemplateID;
+    }
+
+    const persistentType = parseInt(options.type, 10);
+    if (!isNaN(persistentType)) {
+        reqParams.type = persistentType;
+    }
+
+    util.prepareZone(this, this.mac.accessKey, bucket, function (err, ctx) {
+        if (err) {
+            callbackFunc(err, null, null);
+            return;
+        }
+        pfopReq(ctx.mac, ctx.config, reqParams, callbackFunc);
+    });
+};
+
+function pfopReq (mac, config, reqParams, callbackFunc) {
+    const scheme = config.useHttpsDomain ? 'https://' : 'http://';
+    const requestURI = scheme + config.zone.apiHost + '/pfop/';
+    const reqBody = querystring.stringify(reqParams);
+    const auth = util.generateAccessToken(mac, requestURI, reqBody);
+    rpc.postWithForm(requestURI, reqBody, auth, callbackFunc);
+}
+
+/**
+ * 查询持久化数据处理进度
+ * @param {string} persistentId
+ * @param {OperationCallback} callbackFunc 回调函数
+ */
+OperationManager.prototype.prefop = function (
+    persistentId,
+    callbackFunc
+) {
+    let apiHost = 'api.qiniu.com';
+    if (this.config.zone) {
+        apiHost = this.config.zone.apiHost;
+    }
+
+    const scheme = this.config.useHttpsDomain ? 'https://' : 'http://';
+    const requestURI = scheme + apiHost + '/status/get/prefop';
+    const reqParams = {
+        id: persistentId
+    };
+    const reqBody = querystring.stringify(reqParams);
+    rpc.postWithForm(requestURI, reqBody, null, callbackFunc);
+};

package/dist/weixin/node_modules/qiniu/qiniu/httpc/client.js

@@ -0,0 +1,253 @@
+const http = require('http');
+const https = require('https');
+
+const urllib = require('urllib');
+
+const middleware = require('./middleware');
+const { ResponseWrapper } = require('./responseWrapper');
+
+/**
+ *
+ * @param {Object} options
+ * @param {http.Agent} [options.httpAgent]
+ * @param {https.Agent} [options.httpsAgent]
+ * @param {middleware.Middleware[]} [options.middlewares]
+ * @param {number | number[]} [options.timeout]
+ * @constructor
+ */
+function HttpClient (options) {
+    this.httpAgent = options.httpAgent || http.globalAgent;
+    this.httpsAgent = options.httpsAgent || https.globalAgent;
+    this.middlewares = options.middlewares || [];
+    this.timeout = options.timeout;
+}
+
+HttpClient.prototype._handleRequest = function (req) {
+    return new Promise((resolve, reject) => {
+        try {
+            urllib.request(req.url, req.urllibOptions, (err, data, resp) => {
+                if (err) {
+                    err.resp = resp;
+                    reject(err);
+                    return;
+                }
+                resolve(new ResponseWrapper({ data, resp }));
+            });
+        } catch (e) {
+            reject(e);
+        }
+    });
+};
+
+/**
+ * Options for request
+ * @typedef {Object} ReqOpts
+ * @property {http.Agent} [agent]
+ * @property {https.Agent} [httpsAgent]
+ * @property {string} url
+ * @property {middleware.Middleware[]} [middlewares]
+ * @property {urllib.Callback} [callback]
+ * @property {urllib.RequestOptions} urllibOptions
+ */
+
+/**
+ *
+ * @param {ReqOpts} requestOptions
+ * @returns {Promise<ResponseWrapper>}
+ */
+HttpClient.prototype.sendRequest = function (requestOptions) {
+    const mwList = this.middlewares.concat(requestOptions.middlewares || []);
+
+    if (!requestOptions.agent) {
+        requestOptions.agent = this.httpAgent;
+    }
+
+    if (!requestOptions.httpsAgent) {
+        requestOptions.httpsAgent = this.httpsAgent;
+    }
+
+    if (!requestOptions.urllibOptions.headers) {
+        requestOptions.urllibOptions.headers = {};
+    }
+
+    if (!requestOptions.urllibOptions.headers['Content-Type']) {
+        requestOptions.urllibOptions.headers['Content-Type'] = 'application/x-www-form-urlencoded';
+    }
+
+    const handle = middleware.composeMiddlewares(
+        mwList,
+        this._handleRequest
+    );
+
+    const resPromise = handle(requestOptions);
+
+    if (requestOptions.callback) {
+        // user should handle callback error outside.
+        // already wrapped callback for inner usage in storage.
+        resPromise.then(({ data, resp }) => {
+            requestOptions.callback(null, data, resp);
+        });
+        // no chained for preventing callback twice when callback errored.
+        resPromise.catch(err => {
+            requestOptions.callback(err, null, err.resp);
+        });
+    }
+
+    return resPromise;
+};
+
+/**
+ * @param {Object} reqOptions
+ * @param {string} reqOptions.url
+ * @param {http.Agent} [reqOptions.agent]
+ * @param {https.Agent} [reqOptions.httpsAgent]
+ * @param {Object} [reqOptions.params]
+ * @param {Object} [reqOptions.headers]
+ * @param {middleware.Middleware[]} [reqOptions.middlewares]
+ * @param {urllib.RequestOptions} [urllibOptions]
+ * @returns {Promise<ResponseWrapper>}
+ */
+HttpClient.prototype.get = function (reqOptions, urllibOptions) {
+    const {
+        url,
+        params,
+        headers,
+        middlewares,
+        agent,
+        httpsAgent,
+        callback
+    } = reqOptions;
+
+    urllibOptions = urllibOptions || {};
+    urllibOptions.method = 'GET';
+    urllibOptions.headers = Object.assign(
+        {
+            Connection: 'keep-alive'
+        },
+        headers,
+        urllibOptions.headers || {}
+    );
+    urllibOptions.data = params;
+    urllibOptions.followRedirect = true;
+    urllibOptions.gzip = urllibOptions.gzip !== undefined ? urllibOptions.gzip : true;
+    urllibOptions.dataType = urllibOptions.dataType || 'json';
+    urllibOptions.timeout = urllibOptions.timeout || this.timeout;
+
+    return this.sendRequest({
+        url: url,
+        middlewares: middlewares,
+        agent: agent,
+        httpsAgent: httpsAgent,
+        callback: callback,
+        urllibOptions: urllibOptions
+    });
+};
+
+/**
+ * @param {Object} reqOptions
+ * @param {string} reqOptions.url
+ * @param {http.Agent} [reqOptions.agent]
+ * @param {https.Agent} [reqOptions.httpsAgent]
+ * @param {string | Buffer | Readable} [reqOptions.data]
+ * @param {Object} [reqOptions.headers]
+ * @param {middleware.Middleware[]} [reqOptions.middlewares]
+ * @param {function(err: Error | null, ret: any, info: IncomingMessage): void} [reqOptions.callback]
+ * @param {urllib.RequestOptions} [urllibOptions]
+ * @returns {Promise<ResponseWrapper>}
+ */
+HttpClient.prototype.post = function (reqOptions, urllibOptions) {
+    const {
+        url,
+        data,
+        headers,
+        middlewares,
+        agent,
+        httpsAgent,
+        callback
+    } = reqOptions;
+
+    urllibOptions = urllibOptions || {};
+    urllibOptions.method = 'POST';
+    urllibOptions.headers = Object.assign(
+        {
+            Connection: 'keep-alive'
+        },
+        headers,
+        urllibOptions.headers || {}
+    );
+    urllibOptions.gzip = urllibOptions.gzip !== undefined ? urllibOptions.gzip : true;
+    urllibOptions.dataType = urllibOptions.dataType || 'json';
+    urllibOptions.timeout = urllibOptions.timeout || this.timeout;
+
+    if (Buffer.isBuffer(data) || typeof data === 'string') {
+        urllibOptions.content = data;
+    } else if (data) {
+        urllibOptions.stream = data;
+    } else {
+        urllibOptions.headers['Content-Length'] = '0';
+    }
+
+    return this.sendRequest({
+        url: url,
+        middlewares: middlewares,
+        agent: agent,
+        httpsAgent: httpsAgent,
+        callback: callback,
+        urllibOptions: urllibOptions
+    });
+};
+
+/**
+ * @param {Object} reqOptions
+ * @param {string} reqOptions.url
+ * @param {http.Agent} [reqOptions.agent]
+ * @param {https.Agent} [reqOptions.httpsAgent]
+ * @param {string | Buffer | ReadableStream} [reqOptions.data]
+ * @param {Object} [reqOptions.headers]
+ * @param {middleware.Middleware[]} [reqOptions.middlewares]
+ * @param {urllib.RequestOptions} [urllibOptions]
+ * @returns {Promise<ResponseWrapper>}
+ */
+HttpClient.prototype.put = function (reqOptions, urllibOptions) {
+    const {
+        url,
+        data,
+        headers,
+        middlewares,
+        agent,
+        httpsAgent,
+        callback
+    } = reqOptions;
+
+    urllibOptions = urllibOptions || {};
+    urllibOptions.method = 'PUT';
+    urllibOptions.headers = Object.assign(
+        {
+            Connection: 'keep-alive'
+        },
+        headers,
+        urllibOptions.headers || {}
+    );
+    urllibOptions.gzip = urllibOptions.gzip !== undefined ? urllibOptions.gzip : true;
+    urllibOptions.dataType = urllibOptions.dataType || 'json';
+    urllibOptions.timeout = urllibOptions.timeout || this.timeout;
+
+    if (Buffer.isBuffer(data) || typeof data === 'string') {
+        urllibOptions.content = data;
+    } else if (data) {
+        urllibOptions.stream = data;
+    } else {
+        urllibOptions.headers['Content-Length'] = '0';
+    }
+
+    return this.sendRequest({
+        url: url,
+        middlewares: middlewares,
+        agent: agent,
+        httpsAgent: httpsAgent,
+        callback: callback,
+        urllibOptions: urllibOptions
+    });
+};
+
+exports.HttpClient = HttpClient;

package/dist/weixin/node_modules/qiniu/qiniu/httpc/endpoint.js

@@ -0,0 +1,66 @@
+/**
+ * @interface EndpointsProvider
+ */
+
+/**
+ * @function
+ * @name EndpointsProvider#getEndpoints
+ * @returns {Promise<Endpoint[]>}
+ */
+
+/**
+ * @interface MutableEndpointsProvider
+ * @extends EndpointsProvider
+ */
+
+/**
+ * @function
+ * @name MutableEndpointsProvider#setEndpoints
+ * @param {endpoints: Endpoint[]} endpoints
+ * @returns {Promise<void>}
+ */
+
+// --- could split to files if migrate to typescript --- //
+
+/**
+ * @class
+ * @implements EndpointsProvider
+ * @param {string} host
+ * @param {Object} [options]
+ * @param {string} [options.defaultScheme]
+ * @constructor
+ */
+function Endpoint (host, options) {
+    options = options || {};
+
+    this.host = host;
+    this.defaultScheme = options.defaultScheme || 'https';
+}
+
+/**
+ * @param {Object} [options]
+ * @param {string} [options.scheme]
+ */
+Endpoint.prototype.getValue = function (options) {
+    options = options || {};
+
+    const scheme = options.scheme || this.defaultScheme;
+    const host = this.host;
+
+    return scheme + '://' + host;
+};
+
+/**
+ * @returns {Promise<Endpoint[]>}
+ */
+Endpoint.prototype.getEndpoints = function () {
+    return Promise.resolve([this]);
+};
+
+Endpoint.prototype.clone = function () {
+    return new Endpoint(this.host, {
+        defaultScheme: this.defaultScheme
+    });
+};
+
+exports.Endpoint = Endpoint;

package/dist/weixin/node_modules/qiniu/qiniu/httpc/endpointsProvider.js

@@ -0,0 +1,27 @@
+/**
+ * @class
+ * @implements EndpointsProvider
+ * @property {Endpoint[]} endpoints
+ * @constructor
+ * @param {Endpoint[]} endpoints
+ */
+function StaticEndpointsProvider (endpoints) {
+    this.endpoints = endpoints;
+}
+
+/**
+ * @param {Region} region
+ * @param {string} serviceName
+ */
+StaticEndpointsProvider.fromRegion = function (region, serviceName) {
+    return new StaticEndpointsProvider(region.services[serviceName]);
+};
+
+/**
+ * @returns {Promise<Endpoint[]>}
+ */
+StaticEndpointsProvider.prototype.getEndpoints = function () {
+    return Promise.resolve(this.endpoints);
+};
+
+exports.StaticEndpointsProvider = StaticEndpointsProvider;