xshell 1.0.197 → 1.0.200

package/net.browser.d.ts

@@ -90,12 +90,14 @@ export declare class WebSocketConnectionError extends Error {
         - on_error?: 在 websocket 出错和非正常关闭 (close, error 事件) 时都调用，可以根据 error.type 来区分，error 的类型是 WebSocketConnectionError，
             type 为 'close' 时有 code 和 reason 属性
         - on_close?: 和 websocket 的 'close' 事件不相同，只在正常关闭 (close code 为 1000) 时才调用，否则都会调用 on_error
-            https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent#Status_codes  */
-export declare function connect_websocket(url: string | URL, { protocols, on_message, on_error, on_close, }: {
+            https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent#Status_codes
+        - print?: 是否打印连接、关闭信息 */
+export declare function connect_websocket(url: string | URL, { protocols, on_message, on_error, on_close, print }: {
     protocols?: string[];
     on_message(data: ArrayBuffer | string, websocket: WebSocket): any;
     on_error?(error: WebSocketConnectionError, websocket: WebSocket): any;
     on_close?(event: CloseEvent, websocket: WebSocket): any;
+    print?: boolean;
 }): Promise<WebSocket>;
 /** 接收到消息后的处理函数
     返回值可以是:
@@ -185,8 +187,10 @@ export declare class Remote {
         一元 rpc 接收方不需要设置 handlers, 发送方需要 */
     handlers: Map<number, MessageHandler<any[]>>;
     keeper?: RemoteKeeperOptions;
-    /** `false` 打印所有交互的 rpc messages */
+    /** `true` 是否打印连接信息、错误信息 */
     print: boolean;
+    /** `false` 打印所有交互的 rpc messages */
+    verbose: boolean;
     first_error: boolean;
     keeping: boolean;
     reconnecting: boolean;
@@ -196,10 +200,11 @@ export declare class Remote {
     static pack({ id, func, data, done, error }: Message): Uint8Array;
     /** 作为 websocket 连接发起方，传入 url 或 websocket，定义远程 Remote
         作为 websocket 连接接收方，不传 url 和 websocket，定义本地 Remote */
-    constructor({ url, funcs, print, websocket, keeper, on_error, }?: {
+    constructor({ url, funcs, print, verbose, websocket, keeper, on_error, }?: {
         url?: string;
         funcs?: Remote['funcs'];
         print?: boolean;
+        verbose?: boolean;
         websocket?: WebSocket;
         keeper?: RemoteKeeperOptions;
         on_error?(error: WebSocketConnectionError, websocket?: WebSocket): void;

package/net.browser.js

@@ -1,6 +1,6 @@
 import { t } from './i18n/instance.js';
 import './prototype.browser.js'; // to_time_str()
-import { assert, concat, genid, delay, Lock, encode, decode, timeout } from './utils.browser.js';
+import { assert, concat, genid, delay, Lock, encode, decode, timeout, check } from './utils.browser.js';
 const drop_request_headers = new Set([
     // : 开头的 key
     // sec-*
@@ -186,26 +186,29 @@ export class WebSocketConnectionError extends Error {
         - on_error?: 在 websocket 出错和非正常关闭 (close, error 事件) 时都调用，可以根据 error.type 来区分，error 的类型是 WebSocketConnectionError，
             type 为 'close' 时有 code 和 reason 属性
         - on_close?: 和 websocket 的 'close' 事件不相同，只在正常关闭 (close code 为 1000) 时才调用，否则都会调用 on_error
-            https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent#Status_codes  */
-export async function connect_websocket(url, { protocols, on_message, on_error, on_close, }) {
+            https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent#Status_codes
+        - print?: 是否打印连接、关闭信息 */
+export async function connect_websocket(url, { protocols, on_message, on_error, on_close, print = true }) {
     let websocket = new WebSocket(url, protocols);
     // https://stackoverflow.com/questions/11821096/what-is-the-difference-between-an-arraybuffer-and-a-blob/39951543
     websocket.binaryType = 'arraybuffer';
     return new Promise((resolve, reject) => {
         let settled = false;
         websocket.addEventListener('open', event => {
-            console.log(websocket.url +
-                (websocket.protocol ? ' ' + websocket.protocol.bracket() : '') +
-                t(' 已连接'));
+            if (print)
+                console.log(websocket.url +
+                    (websocket.protocol ? ' ' + websocket.protocol.bracket() : '') +
+                    t(' 已连接'));
             settled = true;
             resolve(websocket);
         });
         websocket.addEventListener('close', event => {
-            if (event.code === 1000) // 正常关闭
+            if (event.code === 1000) { // 正常关闭
                 if (on_close)
                     on_close(event, websocket);
-                else
+                else if (print)
                     console.log(`${websocket.url} ${t('已正常关闭')}`);
+            }
             else { // 异常关闭，认为发生了错误，进行错误处理
                 const error = new WebSocketConnectionError(websocket.url, protocols, event, `${t('连接被关闭')}, code: ${event.code}${event.reason ? `, ${t('原因')}: ${event.reason}` : ''}`);
                 if (settled)
@@ -278,8 +281,10 @@ export class Remote {
         一元 rpc 接收方不需要设置 handlers, 发送方需要 */
     handlers = new Map();
     keeper;
+    /** `true` 是否打印连接信息、错误信息 */
+    print = true;
     /** `false` 打印所有交互的 rpc messages */
-    print = false;
+    verbose = false;
     first_error = true;
     keeping = false;
     reconnecting = false;
@@ -305,7 +310,6 @@ export class Remote {
         return message;
     }
     static pack({ id, func, data = [], done, error }) {
-        assert('length' in data, 'message.data 必须是数组');
         let data_ = new Array(data.length);
         let bins = [];
         let bufs = [];
@@ -335,12 +339,12 @@ export class Remote {
     }
     /** 作为 websocket 连接发起方，传入 url 或 websocket，定义远程 Remote
         作为 websocket 连接接收方，不传 url 和 websocket，定义本地 Remote */
-    constructor({ url, funcs, print, websocket, keeper, on_error, } = {}) {
-        assert(!(url && websocket), '构建 Remote 时 url 和 websocket 最多只能传一个');
+    constructor({ url, funcs, print, verbose, websocket, keeper, on_error, } = {}) {
+        check(!(url && websocket), '构建 Remote 时 url 和 websocket 最多只能传一个');
         this.initiator = Boolean(url || websocket);
         if (url)
             this.url = url;
-        assert(!funcs?.echo);
+        check(!funcs?.echo);
         this.funcs = this.initiator ? funcs : {
             ...funcs,
             echo({ data }) {
@@ -349,12 +353,14 @@ export class Remote {
         };
         if (print !== undefined)
             this.print = print;
+        if (verbose !== undefined)
+            this.verbose = verbose;
         if (on_error)
             this.on_error = on_error;
         if (this.initiator)
             this.lwebsocket = new Lock(websocket || null);
         if (keeper) {
-            assert(this.initiator && url);
+            check(this.initiator && url);
             this.keeper = {
                 reconnect_interval: 1000 * 5,
                 heartbeat_interval: 1000 * 60,
@@ -380,14 +386,13 @@ export class Remote {
                 this.reconnecting = false;
                 if (!this.disconnected)
                     try {
-                        await timeout(3000, async () => {
-                            await this.connect();
-                        });
+                        await timeout(3000, async () => { await this.connect(); }, undefined, this.print);
                         this.first_error = true;
                     }
                     catch (error) {
                         // 重连失败的错误这里需要简单打印下，_on_error 不会打印，这里也不继续往上抛了
-                        console.log(error.message);
+                        if (this.print)
+                            console.log(error.message);
                         // 重连由 this.connect 里面调用 this._on_error 处理
                     }
             })();
@@ -397,8 +402,10 @@ export class Remote {
     };
     /** 使用者自定义的在连接后出错时的处理 */
     on_error(error, websocket) {
-        if (this.keeper)
-            console.log(error.message);
+        if (this.keeper) {
+            if (this.print)
+                console.log(error.message);
+        }
         else
             throw error;
     }
@@ -424,7 +431,8 @@ export class Remote {
                         try {
                             this.lwebsocket.resource = await connect_websocket(this.url, {
                                 on_message: this._on_message,
-                                on_error: this._on_error
+                                on_error: this._on_error,
+                                print: this.print
                             });
                             reconnected = true;
                         }
@@ -446,12 +454,11 @@ export class Remote {
                                     break;
                                 if (!this.reconnecting)
                                     try {
-                                        await timeout(1000 * 2, async () => {
-                                            await this.call('echo', []);
-                                        });
+                                        await timeout(1000 * 2, async () => { await this.call('echo', []); }, undefined, this.print);
                                     }
                                     catch (error) {
-                                        console.log(error.message);
+                                        if (this.print)
+                                            console.log(error.message);
                                         this._on_error(error);
                                     }
                             }
@@ -474,8 +481,8 @@ export class Remote {
         作为 websocket 连接接收方，必传 websocket 参数
         发送或连接出错时自动清理 message.id 对应的 handler */
     async send(message, websocket) {
-        assert(!message.data || message.data.every(arg => arg !== undefined), `message.data 数组中不能有 undefined 的项, 因为 json 序列化后会变为 null. (func: ${message.func}, id: ${message.id})`);
-        if (this.print)
+        check(!message.data || message.data.every(arg => arg !== undefined), `message.data 数组中不能有 undefined 的项, 因为 json 序列化后会变为 null. (func: ${message.func}, id: ${message.id})`);
+        if (this.verbose)
             console.log('remote.send:', message);
         try {
             await this.connect(websocket);
@@ -496,7 +503,7 @@ export class Remote {
     async handle(data, websocket) {
         const message = Remote.parse(data);
         const { id, func, done } = message;
-        if (this.print)
+        if (this.verbose)
             console.log('remote.handle:', message);
         let handler;
         if (func)

package/net.d.ts

@@ -147,15 +147,17 @@ export declare class WebSocketConnectionError extends Error {
         - on_error?: 在 websocket 出错和非正常关闭 (close, error 事件) 时都调用，可以根据 error.type 来区分，error 的类型是 WebSocketConnectionError，
             type 为 'close' 时有 code 和 reason 属性
         - on_close?: 和 websocket 的 'close' 事件不相同，只在正常关闭 (close code 为 1000) 时才调用，否则都会调用 on_error
-            https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent#Status_codes  */
+            https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent#Status_codes
+        - print?: 是否打印连接、关闭信息 */
 export declare function connect_websocket(url: string | URL, { protocols, max_payload, // 8 GB
-on_message, on_error, on_close, proxy }: {
+on_message, on_error, on_close, proxy, print, }: {
     protocols?: string[];
     max_payload?: number;
     on_message(data: ArrayBuffer | string, websocket: WebSocket): any;
     on_error?(error: WebSocketConnectionError, websocket: WebSocket): any;
     on_close?(event: CloseEvent, websocket: WebSocket): any;
     proxy?: string;
+    print?: boolean;
 }): Promise<WebSocket>;
 /** 接收到消息后的处理函数
     返回值可以是:
@@ -245,8 +247,10 @@ export declare class Remote {
         一元 rpc 接收方不需要设置 handlers, 发送方需要 */
     handlers: Map<number, MessageHandler<any[]>>;
     keeper?: RemoteKeeperOptions;
-    /** `false` 打印所有交互的 rpc messages */
+    /** `true` 是否打印连接信息、错误信息 */
     print: boolean;
+    /** `false` 打印所有交互的 rpc messages */
+    verbose: boolean;
     first_error: boolean;
     keeping: boolean;
     reconnecting: boolean;
@@ -256,10 +260,11 @@ export declare class Remote {
     static pack({ id, func, data, done, error }: Message): Uint8Array;
     /** 作为 websocket 连接发起方，传入 url 或 websocket，定义远程 Remote
         作为 websocket 连接接收方，不传 url 和 websocket，定义本地 Remote */
-    constructor({ url, funcs, print, websocket, keeper, on_error, }?: {
+    constructor({ url, funcs, print, verbose, websocket, keeper, on_error, }?: {
         url?: string;
         funcs?: Remote['funcs'];
         print?: boolean;
+        verbose?: boolean;
         websocket?: WebSocket;
         keeper?: RemoteKeeperOptions;
         on_error?(error: WebSocketConnectionError, websocket?: WebSocket): void;

package/net.js

@@ -3,7 +3,7 @@ import { buffer as stream_to_buffer, text as stream_to_text } from 'stream/consu
 import { isReadable } from 'stream';
 import { t } from './i18n/instance.js';
 import './prototype.js';
-import { inspect, concat, assert, genid, delay, Lock, encode, decode, pipe_with_error, map_values, unique, timeout } from './utils.js';
+import { inspect, concat, assert, genid, delay, Lock, encode, decode, pipe_with_error, map_values, unique, timeout, check } from './utils.js';
 export const WebSocketConnecting = 0;
 export const WebSocketOpen = 1;
 export const WebSocketClosing = 2;
@@ -396,9 +396,10 @@ let websocket_proxy_agents = {};
         - on_error?: 在 websocket 出错和非正常关闭 (close, error 事件) 时都调用，可以根据 error.type 来区分，error 的类型是 WebSocketConnectionError，
             type 为 'close' 时有 code 和 reason 属性
         - on_close?: 和 websocket 的 'close' 事件不相同，只在正常关闭 (close code 为 1000) 时才调用，否则都会调用 on_error
-            https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent#Status_codes  */
+            https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent#Status_codes
+        - print?: 是否打印连接、关闭信息 */
 export async function connect_websocket(url, { protocols, max_payload = 2 ** 33, // 8 GB
-on_message, on_error, on_close, proxy }) {
+on_message, on_error, on_close, proxy, print = true, }) {
     const { WebSocket } = await import('ws');
     const { HttpsProxyAgent } = await import('https-proxy-agent');
     let websocket = new WebSocket(url, protocols, {
@@ -414,9 +415,10 @@ on_message, on_error, on_close, proxy }) {
     return new Promise((resolve, reject) => {
         let settled = false;
         websocket.addEventListener('open', event => {
-            console.log(websocket.url +
-                (websocket.protocol ? ' ' + websocket.protocol.bracket() : '') +
-                t(' 已连接'));
+            if (print)
+                console.log(websocket.url +
+                    (websocket.protocol ? ' ' + websocket.protocol.bracket() : '') +
+                    t(' 已连接'));
             settled = true;
             resolve(websocket);
         });
@@ -426,13 +428,14 @@ on_message, on_error, on_close, proxy }) {
             // 接着马上 close 事件也被调用，此时 settled，马上调用了 on_error 函数，弄乱了顺序
             // error 的错误信息比较多，而且通过 await 得到的栈也比较清晰，这里延后调用 on_close 和 on_error，放到微任务队列之后的 timers 队列中
             setTimeout(() => {
-                if (event.code === 1000) // 正常关闭
+                if (event.code === 1000) { // 正常关闭
                     if (on_close)
                         on_close(event, websocket);
-                    else
+                    else if (print)
                         console.log(`${websocket.url} ${t('已正常关闭')}`);
+                }
                 else { // 异常关闭，认为发生了错误，进行错误处理
-                    assert(settled, t('websocket close 事件时应该已经 settled'));
+                    // websocket close 事件时已经 settled
                     const error = new WebSocketConnectionError(websocket.url, protocols, event, `${t('连接被关闭')}, code: ${event.code}${event.reason ? `, ${t('原因')}: ${event.reason}` : ''}`);
                     if (on_error)
                         on_error(error, websocket);
@@ -496,8 +499,10 @@ export class Remote {
         一元 rpc 接收方不需要设置 handlers, 发送方需要 */
     handlers = new Map();
     keeper;
+    /** `true` 是否打印连接信息、错误信息 */
+    print = true;
     /** `false` 打印所有交互的 rpc messages */
-    print = false;
+    verbose = false;
     first_error = true;
     keeping = false;
     reconnecting = false;
@@ -523,7 +528,6 @@ export class Remote {
         return message;
     }
     static pack({ id, func, data = [], done, error }) {
-        assert('length' in data, 'message.data 必须是数组');
         let data_ = new Array(data.length);
         let bins = [];
         let bufs = [];
@@ -553,12 +557,12 @@ export class Remote {
     }
     /** 作为 websocket 连接发起方，传入 url 或 websocket，定义远程 Remote
         作为 websocket 连接接收方，不传 url 和 websocket，定义本地 Remote */
-    constructor({ url, funcs, print, websocket, keeper, on_error, } = {}) {
-        assert(!(url && websocket), '构建 Remote 时 url 和 websocket 最多只能传一个');
+    constructor({ url, funcs, print, verbose, websocket, keeper, on_error, } = {}) {
+        check(!(url && websocket), '构建 Remote 时 url 和 websocket 最多只能传一个');
         this.initiator = Boolean(url || websocket);
         if (url)
             this.url = url;
-        assert(!funcs?.echo);
+        check(!funcs?.echo);
         this.funcs = this.initiator ? funcs : {
             ...funcs,
             echo({ data }) {
@@ -567,12 +571,14 @@ export class Remote {
         };
         if (print !== undefined)
             this.print = print;
+        if (verbose !== undefined)
+            this.verbose = verbose;
         if (on_error)
             this.on_error = on_error;
         if (this.initiator)
             this.lwebsocket = new Lock(websocket || null);
         if (keeper) {
-            assert(this.initiator && url);
+            check(this.initiator && url);
             this.keeper = {
                 reconnect_interval: 1000 * 5,
                 heartbeat_interval: 1000 * 60,
@@ -598,14 +604,13 @@ export class Remote {
                 this.reconnecting = false;
                 if (!this.disconnected)
                     try {
-                        await timeout(3000, async () => {
-                            await this.connect();
-                        });
+                        await timeout(3000, async () => { await this.connect(); }, undefined, this.print);
                         this.first_error = true;
                     }
                     catch (error) {
                         // 重连失败的错误这里需要简单打印下，_on_error 不会打印，这里也不继续往上抛了
-                        console.log(error.message);
+                        if (this.print)
+                            console.log(error.message);
                         // 重连由 this.connect 里面调用 this._on_error 处理
                     }
             })();
@@ -615,8 +620,10 @@ export class Remote {
     };
     /** 使用者自定义的在连接后出错时的处理 */
     on_error(error, websocket) {
-        if (this.keeper)
-            console.log(error.message);
+        if (this.keeper) {
+            if (this.print)
+                console.log(error.message);
+        }
         else
             throw error;
     }
@@ -642,7 +649,8 @@ export class Remote {
                         try {
                             this.lwebsocket.resource = await connect_websocket(this.url, {
                                 on_message: this._on_message,
-                                on_error: this._on_error
+                                on_error: this._on_error,
+                                print: this.print
                             });
                             reconnected = true;
                         }
@@ -664,12 +672,11 @@ export class Remote {
                                     break;
                                 if (!this.reconnecting)
                                     try {
-                                        await timeout(1000 * 2, async () => {
-                                            await this.call('echo', []);
-                                        });
+                                        await timeout(1000 * 2, async () => { await this.call('echo', []); }, undefined, this.print);
                                     }
                                     catch (error) {
-                                        console.log(error.message);
+                                        if (this.print)
+                                            console.log(error.message);
                                         this._on_error(error);
                                     }
                             }
@@ -692,8 +699,8 @@ export class Remote {
         作为 websocket 连接接收方，必传 websocket 参数
         发送或连接出错时自动清理 message.id 对应的 handler */
     async send(message, websocket) {
-        assert(!message.data || message.data.every(arg => arg !== undefined), `message.data 数组中不能有 undefined 的项, 因为 json 序列化后会变为 null. (func: ${message.func}, id: ${message.id})`);
-        if (this.print)
+        check(!message.data || message.data.every(arg => arg !== undefined), `message.data 数组中不能有 undefined 的项, 因为 json 序列化后会变为 null. (func: ${message.func}, id: ${message.id})`);
+        if (this.verbose)
             console.log('remote.send:', message);
         try {
             await this.connect(websocket);
@@ -714,7 +721,7 @@ export class Remote {
     async handle(data, websocket) {
         const message = Remote.parse(data);
         const { id, func, done } = message;
-        if (this.print)
+        if (this.verbose)
             console.log('remote.handle:', message);
         let handler;
         if (func)

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "xshell",
-    "version": "1.0.197",
+    "version": "1.0.200",
     "type": "module",
     "main": "./index.js",
     "bin": {
@@ -81,7 +81,7 @@
         "gulp-sort": "^2.0.0",
         "hash-string": "^1.0.0",
         "https-proxy-agent": "^7.0.5",
-        "i18next": "^23.16.5",
+        "i18next": "^23.16.8",
         "i18next-scanner": "^4.6.0",
         "koa": "^2.15.3",
         "koa-compress": "^5.1.1",
@@ -126,7 +126,7 @@
         "@types/koa-compress": "^4.0.6",
         "@types/lodash": "^4.17.13",
         "@types/mime-types": "^2.1.4",
-        "@types/node": "^22.9.0",
+        "@types/node": "^22.9.1",
         "@types/react": "^18.3.12",
         "@types/through2": "^2.0.41",
         "@types/tough-cookie": "^4.0.5",

package/process.d.ts

@@ -82,6 +82,7 @@ export interface CallOptions extends StartOptions {
         stdout?: (chunk: string) => void;
         stderr?: (chunk: string) => void;
     };
+    on_child?: (child: ChildProcess) => void;
 }
 export interface CallResult<TOutput extends string | Buffer = string> {
     pid: number;
@@ -111,10 +112,12 @@ export interface CallError {
         - encoding?: `'utf-8'` 子进程输出编码, 设置为 binary 时返回 stdout, stderr 类型为 Buffer; 否则是 string
             child output encoding. When set to binary, return stdout, stderr is of type Buffer; otherwise it is string
         - print?: `true` print 选项，支持设置细项  print option (with details)
+        - printers?: 实时处理 stdout 和 stderr 的每个 chunk
         - stdio?: `'pipe'` 设置为 'ignore' 时忽略 stdio 处理  when 'ignore' then ignore stdio processing
         - input?: string, 启动子进程之后写入到子进程 stdin 中的内容，写完后关闭子进程 stdin (pty 不关闭)
         - detached?: `false` 是否断开和 child 的关系 (ignore stdio, unref)  whether to break the connection with child (ignore stdio, unref)
-        - throw_code?: `true` code 不为 0 时是否抛出异常  whether to throw Error when code is not 0 */
+        - throw_code?: `true` code 不为 0 时是否抛出异常  whether to throw Error when code is not 0
+        - on_child: 可以传入回调函数及时获取通过 start 创建的子进程，便于执行 kill、获得 pid 等操作 */
 export declare function call(exe: string, args?: string[]): Promise<CallResult<string>>;
 export declare function call(exe: string, args?: string[], options?: CallOptions & {
     encoding: 'binary';

package/process.js

@@ -116,7 +116,7 @@ export async function start_nodejs(js, args = [], options) {
     return start(exe_nodejs, [js, ...args], options);
 }
 export async function call(exe, args = [], options = {}) {
-    const { encoding = 'utf-8', throw_code = true, printers } = options;
+    const { encoding = 'utf-8', throw_code = true, printers, on_child } = options;
     let { stdio = 'pipe', print = true } = options;
     if (typeof print === 'boolean')
         print = {
@@ -138,6 +138,7 @@ export async function call(exe, args = [], options = {}) {
         ...options,
         print: false,
     });
+    on_child?.(child);
     // --- collect output
     let stdouts = [];
     let stderrs = [];

package/server.d.ts

@@ -105,8 +105,9 @@ export declare class Server {
             - headers?: 修改 (添加、覆盖、null 值时删除) 请求的 http headers, Record<string, string | null>
             - queries?: 修改 (添加、覆盖、null 值时删除) 请求的 http queries, Record<string, string | null>
             - redirect?: `manual` 重定向处理策略，默认按原样返回给客户端
-            - timeout?: `1000 * 5` 请求超时时间，可以传入 0 禁用超时 */
-    request(ctx: Context, path_url: string | URL, { headers: headers_, redirect, queries, timeout }?: ServerRequestOptions): Promise<true>;
+            - timeout?: `1000 * 5` 请求超时时间，可以传入 0 禁用超时
+            - throw_error?: `false` 在遇到 request 请求错误时直接 throw 出来，而不是自动设置到 response */
+    request(ctx: Context, path_url: string | URL, { headers: headers_, redirect, queries, timeout, throw_error }?: ServerRequestOptions): Promise<true>;
     static filter_response_headers(headers: RawResponse['headers']): Record<string, string>;
     /** 提供静态文件
         @example
@@ -145,4 +146,6 @@ export interface ServerRequestOptions {
     queries?: Record<string, string>;
     redirect?: RequestOptions['redirect'];
     timeout?: RequestOptions['timeout'];
+    throw_error?: boolean;
 }
+export declare const text_plain: "text/plain; charset=utf-8";

package/server.js

@@ -303,7 +303,7 @@ export class Server {
             if (error.status !== 404)
                 console.error(error);
             response.status = error.status || 500;
-            response.set('content-type', 'text/plain; charset=utf-8');
+            response.set('content-type', text_plain);
             response.body = inspect(error, { colors: false });
         }
     }
@@ -465,8 +465,9 @@ export class Server {
             - headers?: 修改 (添加、覆盖、null 值时删除) 请求的 http headers, Record<string, string | null>
             - queries?: 修改 (添加、覆盖、null 值时删除) 请求的 http queries, Record<string, string | null>
             - redirect?: `manual` 重定向处理策略，默认按原样返回给客户端
-            - timeout?: `1000 * 5` 请求超时时间，可以传入 0 禁用超时 */
-    async request(ctx, path_url, { headers: headers_, redirect = 'manual', queries, timeout } = {}) {
+            - timeout?: `1000 * 5` 请求超时时间，可以传入 0 禁用超时
+            - throw_error?: `false` 在遇到 request 请求错误时直接 throw 出来，而不是自动设置到 response */
+    async request(ctx, path_url, { headers: headers_, redirect = 'manual', queries, timeout, throw_error } = {}) {
         const { request: { method, headers, query, body, ip } } = ctx;
         let { response } = ctx;
         const x_forwarded_for = headers['x-forwarded-for'] ? `${headers['x-forwarded-for']}, ${ip}` : ip;
@@ -504,6 +505,8 @@ export class Server {
                     response.body = response_.body;
         }
         catch (error) {
+            if (throw_error)
+                throw error;
             if (error.response?.status !== 404)
                 console.log(error);
             if (error.response) {
@@ -692,4 +695,5 @@ export class Server {
         throw new Error(`端口范围 {${range}} 内没有可用的端口`);
     }
 }
+export const text_plain = 'text/plain; charset=utf-8';
 //# sourceMappingURL=server.js.map

package/utils.browser.d.ts

@@ -28,8 +28,9 @@ export declare class TimeoutError extends Error {
 }
 /** 在指定的时间 (milliseconds) 内运行某个任务，超时之后
     - 如果传入了 on_timeout 参数: 调用 on_timeout，返回 null
-    - 如果没传入 on_timeout 参数: 抛出 TimeoutError */
-export declare function timeout<TReturn>(milliseconds: number, action: () => Promise<TReturn>, on_timeout?: () => void | Promise<void>): Promise<TReturn>;
+    - 如果没传入 on_timeout 参数: 抛出 TimeoutError
+    - print?: 打印已超时任务的错误 */
+export declare function timeout<TReturn>(milliseconds: number, action: () => Promise<TReturn>, on_timeout?: () => void | Promise<void>, print?: boolean): Promise<TReturn>;
 /** https://stackoverflow.com/questions/63297164/how-to-only-accept-arraybuffer-as-parameter */
 export type StrictArrayBuffer = ArrayBuffer & {
     buffer?: undefined;

package/utils.browser.js

@@ -80,8 +80,9 @@ export class TimeoutError extends Error {
 }
 /** 在指定的时间 (milliseconds) 内运行某个任务，超时之后
     - 如果传入了 on_timeout 参数: 调用 on_timeout，返回 null
-    - 如果没传入 on_timeout 参数: 抛出 TimeoutError */
-export async function timeout(milliseconds, action, on_timeout) {
+    - 如果没传入 on_timeout 参数: 抛出 TimeoutError
+    - print?: 打印已超时任务的错误 */
+export async function timeout(milliseconds, action, on_timeout, print = true) {
     const error = new TimeoutError();
     return new Promise((resolve, reject) => {
         let done = false;
@@ -112,8 +113,10 @@ export async function timeout(milliseconds, action, on_timeout) {
                 resolve(await action());
             }
             catch (error) {
-                if (rejected)
-                    console.log(`已超时任务的错误: ${error.message}`);
+                if (rejected) {
+                    if (print)
+                        console.log(`已超时任务的错误: ${error.message}`);
+                }
                 else {
                     rejected = true;
                     reject(error);

package/utils.d.ts

@@ -89,8 +89,9 @@ export declare class TimeoutError extends Error {
 }
 /** 在指定的时间 (milliseconds) 内运行某个任务，超时之后
     - 如果传入了 on_timeout 参数: 调用 on_timeout，返回 null
-    - 如果没传入 on_timeout 参数: 抛出 TimeoutError */
-export declare function timeout<TReturn>(milliseconds: number, action: () => Promise<TReturn>, on_timeout?: () => void | Promise<void>): Promise<TReturn>;
+    - 如果没传入 on_timeout 参数: 抛出 TimeoutError
+    - print?: 打印已超时任务的错误 */
+export declare function timeout<TReturn>(milliseconds: number, action: () => Promise<TReturn>, on_timeout?: () => void | Promise<void>, print?: boolean): Promise<TReturn>;
 /** https://stackoverflow.com/questions/63297164/how-to-only-accept-arraybuffer-as-parameter */
 export type StrictArrayBuffer = ArrayBuffer & {
     buffer?: undefined;

package/utils.js

@@ -251,8 +251,9 @@ export class TimeoutError extends Error {
 }
 /** 在指定的时间 (milliseconds) 内运行某个任务，超时之后
     - 如果传入了 on_timeout 参数: 调用 on_timeout，返回 null
-    - 如果没传入 on_timeout 参数: 抛出 TimeoutError */
-export async function timeout(milliseconds, action, on_timeout) {
+    - 如果没传入 on_timeout 参数: 抛出 TimeoutError
+    - print?: 打印已超时任务的错误 */
+export async function timeout(milliseconds, action, on_timeout, print = true) {
     const error = new TimeoutError();
     return new Promise((resolve, reject) => {
         let done = false;
@@ -283,8 +284,10 @@ export async function timeout(milliseconds, action, on_timeout) {
                 resolve(await action());
             }
             catch (error) {
-                if (rejected)
-                    console.log(`已超时任务的错误: ${error.message}`);
+                if (rejected) {
+                    if (print)
+                        console.log(`已超时任务的错误: ${error.message}`);
+                }
                 else {
                     rejected = true;
                     reject(error);