@byteplus-iga-pages/cli 0.0.0-stage → 1.1.13

package/dist/index.js.LICENSE.txt

@@ -0,0 +1,161 @@
+/*!
+ * Array of passes.
+ *
+ * A `pass` is just a function that is executed on `req, res, options`
+ * so that you can easily add new checks while still keeping the base
+ * flexible.
+ */
+
+/*!
+ * Array of passes.
+ *
+ * A `pass` is just a function that is executed on `req, socket, options`
+ * so that you can easily add new checks while still keeping the base
+ * flexible.
+ */
+
+/*!
+ * Caron dimonio, con occhi di bragia
+ * loro accennando, tutte le raccoglie;
+ * batte col remo qualunque s’adagia 
+ *
+ * Charon the demon, with the eyes of glede,
+ * Beckoning to them, collects them all together,
+ * Beats with his oar whoever lags behind
+ *          
+ *          Dante - The Divine Comedy (Canto III)
+ */
+
+/*!
+ * bytes
+ * Copyright(c) 2012-2014 TJ Holowaychuk
+ * Copyright(c) 2015 Jed Watson
+ * MIT Licensed
+ */
+
+/*!
+ * content-disposition
+ * Copyright(c) 2014 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+/*!
+ * fill-range <https://github.com/jonschlinkert/fill-range>
+ *
+ * Copyright (c) 2014-present, Jon Schlinkert.
+ * Licensed under the MIT License.
+ */
+
+/*!
+ * is-extglob <https://github.com/jonschlinkert/is-extglob>
+ *
+ * Copyright (c) 2014-2016, Jon Schlinkert.
+ * Licensed under the MIT License.
+ */
+
+/*!
+ * is-glob <https://github.com/jonschlinkert/is-glob>
+ *
+ * Copyright (c) 2014-2017, Jon Schlinkert.
+ * Released under the MIT License.
+ */
+
+/*!
+ * is-number <https://github.com/jonschlinkert/is-number>
+ *
+ * Copyright (c) 2014-present, Jon Schlinkert.
+ * Released under the MIT License.
+ */
+
+/*!
+ * mime-db
+ * Copyright(c) 2014 Jonathan Ong
+ * Copyright(c) 2015-2022 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+/*!
+ * mime-db
+ * Copyright(c) 2014 Jonathan Ong
+ * MIT Licensed
+ */
+
+/*!
+ * mime-types
+ * Copyright(c) 2014 Jonathan Ong
+ * Copyright(c) 2015 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+/*!
+ * normalize-path <https://github.com/jonschlinkert/normalize-path>
+ *
+ * Copyright (c) 2014-2018, Jon Schlinkert.
+ * Released under the MIT License.
+ */
+
+/*!
+ * range-parser
+ * Copyright(c) 2012-2014 TJ Holowaychuk
+ * Copyright(c) 2015-2016 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+/*!
+ * to-regex-range <https://github.com/micromatch/to-regex-range>
+ *
+ * Copyright (c) 2015-present, Jon Schlinkert.
+ * Released under the MIT License.
+ */
+
+/*! crc32.js (C) 2014-present SheetJS -- http://sheetjs.com */
+
+/*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */
+
+/**
+ * Archiver Core
+ *
+ * @ignore
+ * @license [MIT]{@link https://github.com/archiverjs/node-archiver/blob/master/LICENSE}
+ * @copyright (c) 2012-2014 Chris Talkington, contributors.
+ */
+
+/**
+ * Archiver Vending
+ *
+ * @ignore
+ * @license [MIT]{@link https://github.com/archiverjs/node-archiver/blob/master/LICENSE}
+ * @copyright (c) 2012-2014 Chris Talkington, contributors.
+ */
+
+/**
+ * JSON Format Plugin
+ *
+ * @module plugins/json
+ * @license [MIT]{@link https://github.com/archiverjs/node-archiver/blob/master/LICENSE}
+ * @copyright (c) 2012-2014 Chris Talkington, contributors.
+ */
+
+/**
+ * TAR Format Plugin
+ *
+ * @module plugins/tar
+ * @license [MIT]{@link https://github.com/archiverjs/node-archiver/blob/master/LICENSE}
+ * @copyright (c) 2012-2014 Chris Talkington, contributors.
+ */
+
+/**
+ * ZIP Format Plugin
+ *
+ * @module plugins/zip
+ * @license [MIT]{@link https://github.com/archiverjs/node-archiver/blob/master/LICENSE}
+ * @copyright (c) 2012-2014 Chris Talkington, contributors.
+ */
+
+/**
+ * ZipStream
+ *
+ * @ignore
+ * @license [MIT]{@link https://github.com/archiverjs/node-zip-stream/blob/master/LICENSE}
+ * @copyright (c) 2014 Chris Talkington, contributors.
+ */

package/dist/request-handler.js

@@ -0,0 +1,458 @@
+// Copyright (c) 2026 BytePlus Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+"use strict";
+var __webpack_modules__ = {
+    stream (module) {
+        module.exports = require("stream");
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+(()=>{
+    __webpack_require__.r(__webpack_exports__);
+    __webpack_require__.d(__webpack_exports__, {
+        RequestHandler: ()=>RequestHandler,
+        calculateRoutePrefix: ()=>calculateRoutePrefix
+    });
+    var stream__rspack_import_0 = __webpack_require__("stream");
+    function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+        try {
+            var info = gen[key](arg);
+            var value = info.value;
+        } catch (error) {
+            reject(error);
+            return;
+        }
+        if (info.done) resolve(value);
+        else Promise.resolve(value).then(_next, _throw);
+    }
+    function _async_to_generator(fn) {
+        return function() {
+            var self = this, args = arguments;
+            return new Promise(function(resolve, reject) {
+                var gen = fn.apply(self, args);
+                function _next(value) {
+                    asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+                }
+                function _throw(err) {
+                    asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+                }
+                _next(void 0);
+            });
+        };
+    }
+    function _define_property(obj, key, value) {
+        if (key in obj) Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+        else obj[key] = value;
+        return obj;
+    }
+    function _object_spread(target) {
+        for(var i = 1; i < arguments.length; i++){
+            var source = null != arguments[i] ? arguments[i] : {};
+            var ownKeys = Object.keys(source);
+            if ("function" == typeof Object.getOwnPropertySymbols) ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+            ownKeys.forEach(function(key) {
+                _define_property(target, key, source[key]);
+            });
+        }
+        return target;
+    }
+    class RequestHandler {
+        execute(handler, context) {
+            return _async_to_generator(function*() {
+                const { req, res, params, routePrefix, method } = context;
+                const HTTP_METHODS = [
+                    "GET",
+                    "POST",
+                    "PUT",
+                    "PATCH",
+                    "DELETE",
+                    "HEAD",
+                    "OPTIONS"
+                ];
+                const hasNamedMethodExports = HTTP_METHODS.some((m)=>handler[m] && "function" == typeof handler[m]);
+                if (handler[method] && "function" == typeof handler[method]) {
+                    yield this.handleWeb((request)=>handler[method](request), context);
+                    return true;
+                }
+                if (hasNamedMethodExports) {
+                    res.statusCode = 405;
+                    res.setHeader("Allow", HTTP_METHODS.filter((m)=>handler[m] && "function" == typeof handler[m]).join(", "));
+                    res.end();
+                    return true;
+                }
+                if (handler.fetch && "function" == typeof handler.fetch) {
+                    yield this.handleWeb((request)=>handler.fetch(request), context);
+                    return true;
+                }
+                if (this.isFrameworkInstance(handler)) {
+                    yield this.handleFramework(handler, req, res, params, routePrefix);
+                    return true;
+                }
+                if ("function" == typeof handler) {
+                    yield this.handleLegacy(handler, req, res, params);
+                    return true;
+                }
+                return false;
+            }).call(this);
+        }
+        isFrameworkInstance(handler) {
+            if ("function" == typeof handler && (handler.handle || handler._router)) return true;
+            if (null !== handler && "object" == typeof handler && "function" == typeof handler.callback && Array.isArray(handler.middleware)) return true;
+            return false;
+        }
+        handleFramework(app, req, res, params, routePrefix) {
+            return _async_to_generator(function*() {
+                req.params = _object_spread({}, req.params, params);
+                const originalUrl = req.url || "/";
+                if (routePrefix && "/" !== routePrefix) {
+                    const pathname = originalUrl.split("?")[0];
+                    const queryString = originalUrl.includes("?") ? originalUrl.substring(originalUrl.indexOf("?")) : "";
+                    const escapedPrefix = this.escapeRegExp(routePrefix);
+                    let newPath = pathname.replace(new RegExp(`^${escapedPrefix}`), "") || "/";
+                    if (!newPath.startsWith("/")) newPath = "/" + newPath;
+                    req.url = newPath + queryString;
+                }
+                try {
+                    yield new Promise((resolve, reject)=>{
+                        const originalEnd = res.end.bind(res);
+                        res.end = function(...args) {
+                            originalEnd(...args);
+                            resolve();
+                            return res;
+                        };
+                        res.on("error", reject);
+                        try {
+                            if ("function" == typeof app) app(req, res, (err)=>{
+                                if (err) reject(err);
+                            });
+                            else {
+                                app.on("error", (err)=>{
+                                    if (err) reject(err);
+                                });
+                                app.callback()(req, res);
+                            }
+                        } catch (error) {
+                            reject(error);
+                        }
+                    });
+                } finally{
+                    req.url = originalUrl;
+                }
+            }).call(this);
+        }
+        handleLegacy(handler, req, res, params) {
+            return _async_to_generator(function*() {
+                const igaReq = req;
+                const igaRes = res;
+                const raw = yield this.readRequestBody(req);
+                this.restoreBody(req, raw);
+                igaReq.query = this.parseQuery(req.url || "");
+                igaReq.params = params;
+                igaReq.cookies = this.parseCookies(req);
+                igaReq.body = this.parseBodyBuffer(raw, req.headers["content-type"], req.method);
+                this.enhanceResponse(igaRes);
+                yield handler(igaReq, igaRes);
+            }).call(this);
+        }
+        restoreBody(req, body) {
+            const pt = new stream__rspack_import_0.PassThrough();
+            const on = pt.on.bind(pt);
+            const originalOn = req.on.bind(req);
+            req.read = pt.read.bind(pt);
+            req.on = req.addListener = (name, cb)=>"data" === name || "end" === name ? on(name, cb) : originalOn(name, cb);
+            pt.write(body);
+            pt.end();
+        }
+        createWebRequest(_0, _1) {
+            return _async_to_generator(function*(req, params = {}, signal) {
+                const protocol = "http";
+                const host = req.headers.host || "localhost";
+                const url = `${protocol}://${host}${req.url}`;
+                const requestInit = {
+                    method: req.method || "GET",
+                    headers: req.headers,
+                    signal
+                };
+                const method = (req.method || "GET").toUpperCase();
+                if ([
+                    "POST",
+                    "PUT",
+                    "PATCH"
+                ].includes(method)) {
+                    const raw = yield this.readRequestBody(req, signal);
+                    if (raw.length) requestInit.body = raw;
+                }
+                const request = new Request(url, requestInit);
+                request.params = params;
+                return request;
+            }).apply(this, arguments);
+        }
+        sendWebResponse(webResponse, res, signal) {
+            return _async_to_generator(function*() {
+                var _webResponse_body;
+                if (signal.aborted) {
+                    var _webResponse_body1;
+                    null == (_webResponse_body1 = webResponse.body) || _webResponse_body1.cancel(signal.reason).catch(()=>void 0);
+                    signal.throwIfAborted();
+                }
+                res.statusCode = webResponse.status;
+                webResponse.headers.forEach((value, key)=>{
+                    res.setHeader(key, value);
+                });
+                const reader = null == (_webResponse_body = webResponse.body) ? void 0 : _webResponse_body.getReader();
+                const cancel = ()=>{
+                    null == reader || reader.cancel(signal.reason).catch(()=>void 0);
+                };
+                signal.addEventListener("abort", cancel, {
+                    once: true
+                });
+                try {
+                    if (signal.aborted) cancel();
+                    signal.throwIfAborted();
+                    if (reader) while(true){
+                        const { done, value } = yield reader.read();
+                        signal.throwIfAborted();
+                        if (done) break;
+                        yield this.writeWebResponse(res, signal, value);
+                    }
+                    yield this.writeWebResponse(res, signal);
+                } catch (error) {
+                    null == reader || reader.cancel(error).catch(()=>void 0);
+                    throw error;
+                } finally{
+                    signal.removeEventListener("abort", cancel);
+                    null == reader || reader.releaseLock();
+                }
+            }).call(this);
+        }
+        writeWebResponse(res, signal, chunk) {
+            return new Promise((resolve, reject)=>{
+                const finish = (error)=>{
+                    res.removeListener("error", onError);
+                    signal.removeEventListener("abort", onAbort);
+                    if (error) reject(error);
+                    else resolve();
+                };
+                const onError = (error)=>finish(error);
+                const onAbort = ()=>finish(signal.reason);
+                res.once("error", onError);
+                signal.addEventListener("abort", onAbort, {
+                    once: true
+                });
+                if (signal.aborted) return onAbort();
+                try {
+                    if (void 0 === chunk) res.end(()=>finish());
+                    else res.write(chunk, finish);
+                } catch (error) {
+                    finish(error);
+                }
+            });
+        }
+        handleWeb(_0, _1) {
+            return _async_to_generator(function*(handler, { req, res, params }) {
+                const controller = new AbortController();
+                const { signal } = controller;
+                const onAborted = ()=>controller.abort(new DOMException("Client disconnected", "AbortError"));
+                const onError = (error)=>controller.abort(error);
+                const onClose = ()=>{
+                    if (!res.writableFinished) onAborted();
+                };
+                req.once("aborted", onAborted);
+                req.once("error", onError);
+                res.once("close", onClose);
+                if (req.aborted || res.destroyed) onAborted();
+                try {
+                    signal.throwIfAborted();
+                    const request = yield this.createWebRequest(req, params, signal);
+                    signal.throwIfAborted();
+                    const response = yield handler(request);
+                    yield this.sendWebResponse(response, res, signal);
+                } catch (error) {
+                    if (signal.aborted && error === signal.reason) return;
+                    if (res.headersSent && !res.destroyed) {
+                        res.removeListener("close", onClose);
+                        res.destroy();
+                    }
+                    throw error;
+                } finally{
+                    req.removeListener("aborted", onAborted);
+                    req.removeListener("error", onError);
+                    res.removeListener("close", onClose);
+                }
+            }).apply(this, arguments);
+        }
+        readRequestBody(req, signal) {
+            return new Promise((resolve, reject)=>{
+                const chunks = [];
+                const cleanup = ()=>{
+                    req.removeListener("data", onData);
+                    req.removeListener("end", onEnd);
+                    req.removeListener("error", onError);
+                    null == signal || signal.removeEventListener("abort", onAbort);
+                };
+                const onData = (chunk)=>chunks.push(chunk);
+                const onEnd = ()=>{
+                    cleanup();
+                    resolve(Buffer.concat(chunks));
+                };
+                const onError = (error)=>{
+                    cleanup();
+                    reject(error);
+                };
+                const onAbort = ()=>onError(null == signal ? void 0 : signal.reason);
+                req.on("data", onData);
+                req.once("end", onEnd);
+                req.once("error", onError);
+                null == signal || signal.addEventListener("abort", onAbort, {
+                    once: true
+                });
+                if (null == signal ? void 0 : signal.aborted) onAbort();
+            });
+        }
+        parseBodyBuffer(raw, contentTypeHeader, method) {
+            const verb = (method || "GET").toUpperCase();
+            if (![
+                "POST",
+                "PUT",
+                "PATCH"
+            ].includes(verb)) return;
+            if (!raw.length) return;
+            const contentType = (contentTypeHeader || "").split(";")[0].trim();
+            if ("application/json" === contentType) try {
+                return JSON.parse(raw.toString("utf-8"));
+            } catch (unused) {
+                throw Object.assign(new Error("Invalid JSON body"), {
+                    statusCode: 400
+                });
+            }
+            if ("application/x-www-form-urlencoded" === contentType) return Object.fromEntries(new URLSearchParams(raw.toString("utf-8")));
+            if ("application/octet-stream" === contentType) return raw;
+            return raw.toString("utf-8");
+        }
+        parseCookies(req) {
+            const header = req.headers.cookie;
+            if (!header) return {};
+            const raw = Array.isArray(header) ? header.join("; ") : header;
+            const result = {};
+            for (const pair of raw.split(";")){
+                const idx = pair.indexOf("=");
+                if (idx < 0) continue;
+                const key = pair.slice(0, idx).trim();
+                const value = pair.slice(idx + 1).trim();
+                if (key) result[key] = decodeURIComponent(value);
+            }
+            return result;
+        }
+        parseQuery(url) {
+            const search = url.includes("?") ? url.slice(url.indexOf("?")) : "";
+            const sp = new URLSearchParams(search);
+            const result = {};
+            for (const key of sp.keys()){
+                const values = sp.getAll(key);
+                result[key] = 1 === values.length ? values[0] : values;
+            }
+            return result;
+        }
+        escapeRegExp(str) {
+            return str.replace(/[|\\{}()[\]^$+*?.]/g, "\\$&");
+        }
+        enhanceResponse(res) {
+            res.json = function(data) {
+                this.setHeader("Content-Type", "application/json; charset=utf-8");
+                this.end(JSON.stringify(data));
+                return this;
+            };
+            res.status = function(code) {
+                this.statusCode = code;
+                return this;
+            };
+            res.send = function(data) {
+                if ("object" == typeof data && null !== data && !Buffer.isBuffer(data)) return this.json(data);
+                if ("string" == typeof data) {
+                    if (!this.getHeader("Content-Type")) this.setHeader("Content-Type", "text/html; charset=utf-8");
+                    this.end(data);
+                    return this;
+                }
+                if (Buffer.isBuffer(data)) {
+                    if (!this.getHeader("Content-Type")) this.setHeader("Content-Type", "application/octet-stream");
+                    this.end(data);
+                    return this;
+                }
+                this.end(String(data));
+                return this;
+            };
+            res.redirect = function(statusOrUrl, url) {
+                if ("string" == typeof statusOrUrl) {
+                    url = statusOrUrl;
+                    statusOrUrl = 307;
+                }
+                if ("number" != typeof statusOrUrl || "string" != typeof url) throw new Error("Invalid redirect arguments. Use res.redirect('/url') or res.redirect(301, '/url').");
+                this.writeHead(statusOrUrl, {
+                    Location: url
+                }).end();
+                return this;
+            };
+        }
+    }
+    function calculateRoutePrefix(route) {
+        const prefix = route.replace(/\/\[\[.*?\]\]$/, "");
+        return prefix || "/";
+    }
+})();
+exports.RequestHandler = __webpack_exports__.RequestHandler;
+exports.calculateRoutePrefix = __webpack_exports__.calculateRoutePrefix;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "RequestHandler",
+    "calculateRoutePrefix"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/package.json

@@ -1,6 +1,28 @@
 {
   "name": "@byteplus-iga-pages/cli",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.1.13",
+  "description": "A CLI tool for BytePlus IGA Pages",
+  "main": "dist/index.js",
+  "bin": {
+    "bp-iga": "./bin/bp-iga.js"
+  },
+  "files": [
+    "bin",
+    "dist"
+  ],
+  "keywords": [
+    "iga-pages",
+    "cli",
+    "deployment",
+    "full-stack",
+    "ai-agent"
+  ],
+  "author": "",
+  "license": "MIT",
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "esbuild": "^0.19.11"
+  }
+}