xshell 1.3.5 → 1.3.7

package/builder.d.ts

@@ -53,6 +53,8 @@ interface AssetOption {
     src: string;
     /** 相对 fpd_out 的路径，或者绝对路径，默认等于 src 的值 */
     out?: string;
+    /** 直接设置 html 的路径，强制覆盖 */
+    value?: string;
 }
 type Assets = {
     productions?: (string | AssetOption)[];
@@ -127,7 +129,7 @@ export declare class Bundler {
         - target: 目标环境 nodejs | web
         - fpd_root: 项目根目录
         - fpd_out: 输出文件目录
-        - fpd_cache: webpack 缓存目录
+        - fpdt_cache?: webpack 缓存目录，可以设置为 undefined 使用默认路径 node_modules/.cache/webpack/
         - entry: 入口文件
         - options?: 打包配置, 按常用顺序排列
             - production?: `true` webpack mode 设置为 'production'

package/builder.js

@@ -104,7 +104,7 @@ const dependencies = {
 function get_asset_out(asset) {
     return typeof asset === 'string'
         ? asset
-        : asset.out || asset.src;
+        : asset.value || asset.out || asset.src;
 }
 function get_vendor_asset_out(asset) {
     return typeof asset === 'string'
@@ -152,7 +152,7 @@ export class Bundler {
         - target: 目标环境 nodejs | web
         - fpd_root: 项目根目录
         - fpd_out: 输出文件目录
-        - fpd_cache: webpack 缓存目录
+        - fpdt_cache?: webpack 缓存目录，可以设置为 undefined 使用默认路径 node_modules/.cache/webpack/
         - entry: 入口文件
         - options?: 打包配置, 按常用顺序排列
             - production?: `true` webpack mode 设置为 'production'

package/development.js

@@ -26,10 +26,10 @@ export function process_stdin(on_key, on_exit) {
 }
 /** 自动配置项目 vscode 设置 */
 export async function setup_vscode_settings(fpd_root) {
-    if (!ramdisk) {
-        const fp_settings = `${fpd_root}.vscode/settings.json`;
-        if (!fexists(fp_settings, noprint))
-            await fcopy(`${fp_settings.strip_end('json')}template.json`, fp_settings);
-    }
+    if (ramdisk)
+        return;
+    const fp_settings = `${fpd_root}.vscode/settings.json`;
+    if (!fexists(fp_settings, noprint))
+        await fcopy(`${fp_settings.strip_end('json')}template.json`, fp_settings);
 }
 //# sourceMappingURL=development.js.map

package/file.js

@@ -747,8 +747,10 @@ export async function ftail(fp, handler, { print = true } = {}) {
 }
 /** 打开一个文件并搜索替换某个 pattern */
 export async function freplace(fp, pattern, replacement, { print = true } = {}) {
-    await fwrite(fp, (await fread(fp, { print }))
-        .replaceAll(pattern, replacement), { print });
+    await fwrite(fp, (await fread(fp, noprint))
+        .replaceAll(pattern, replacement), noprint);
+    if (print)
+        console.log('替换了:', fp);
 }
 /** 同步文件或文件夹 fp_src 到 fp_dst ，返回 fp_dst
     - fp_src: 源文件或文件夹

package/fzip.js

@@ -60,9 +60,7 @@ async function _zip(data, fp_zip, { dirname, print = { files: true, info: true }
         });
         ostream.once('error', reject);
         archive.once('error', reject);
-        archive.on('warning', error => {
-            console.log(error);
-        });
+        archive.on('warning', console.warn);
         archive.pipe(ostream);
         for (const fp in entries) {
             const fdata = entries[fp];

package/net.common.d.ts

@@ -11,23 +11,6 @@ export interface BearerAuth {
     type: 'bearer';
     token: string;
 }
-/** 自动保持 remote 连接，只对 initiator 且传入 url 有效，
-    - 在未连接，或 websocket on_error 检测到连接断开后以 reconnect_interval 间隔尝试 remote.call(func) 重连
-    - 在连接状态下以 heartbeat_interval 间隔发送心跳包确保连接状态
-    
-    配置选项:
-    - func?: 连接后调用的函数，通常为某个 register 函数，将自身注册到 server
-    - args?: 连接后调用函数时传递的参数，与 func 配合使用
-    - reconnect_interval?: `1000 * 5` 首次重连失败后的后续尝试间隔 (单位: ms)
-    - heartbeat_interval?: `1000 * 60` 发送心跳包确保连接的间隔 (单位: ms)
-    - error_delay?: `2000` 遇到错误时首次尝试重连的延时 (单位: ms) */
-export interface RemoteKeeperOptions {
-    func?: string;
-    args?: any[];
-    reconnect_interval?: number;
-    heartbeat_interval?: number;
-    error_delay?: number;
-}
 export declare const WebSocketConnecting = 0;
 export declare const WebSocketOpen = 1;
 export declare const WebSocketClosing = 2;
@@ -49,6 +32,21 @@ export declare class WebSocketConnectionError extends Error {
     static get_reason_string(code: number | string, reason?: string): string | number;
     constructor(url: string, protocols: string[] | undefined, event?: CloseEvent | ErrorEvent, message?: string);
 }
+export interface ConnectWebSocketPrint {
+    connect: boolean;
+    error: boolean;
+    close: boolean;
+}
+export interface ConnectWebsocketOptions {
+    print?: boolean | ConnectWebSocketPrint;
+    protocols?: string[];
+    max_payload?: number;
+    proxy?: string;
+    on_message(data: ArrayBuffer | string, websocket: WebSocket): any;
+    on_error?(error: WebSocketConnectionError, websocket: WebSocket): any;
+    on_close?(event: CloseEvent, websocket: WebSocket): any;
+    connect?: (typeof import('tls'))['connect'] | (typeof import('net'))['connect'];
+}
 /** 连接 websocket url, 设置各种事件监听器。在 open 事件后 resolve, 返回 websocket
     遇到 error, close 事件时会创建 WebSocketConnectionError:
         - reject 掉返回的 promise (若此时未 settle)
@@ -57,7 +55,9 @@ export declare class WebSocketConnectionError extends Error {
     https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/bufferedAmount
     - url
     - options:
-        - print?: 是否打印连接、关闭信息
+        - print?: boolean 或者 ConnectWebSocketPrint，可以控制是否打印连接、正常断开、关闭信息
+            - connect: `true` 连接建立
+            - error: `true` 出错
         - protocols?
         - max_payload?: `8 gb` (仅 nodejs 环境有效)
         - proxy?: string (仅 nodejs 环境有效)
@@ -66,17 +66,10 @@ 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
+        - connect?: nodejs 环境下需要指定 ip, port 手动连接 tls server 时使用，有 agent 时不生效 */
 export declare function connect_websocket(url: string | URL, { print, protocols, max_payload, // 8 GB
-proxy, on_message, on_error, on_close, }: {
-    print?: boolean;
-    protocols?: string[];
-    max_payload?: number;
-    proxy?: string;
-    on_message(data: ArrayBuffer | string, websocket: WebSocket): any;
-    on_error?(error: WebSocketConnectionError, websocket: WebSocket): any;
-    on_close?(event: CloseEvent, websocket: WebSocket): any;
-}): Promise<WebSocket>;
+proxy, on_message, on_error, on_close, connect }: ConnectWebsocketOptions): Promise<WebSocket>;
 /** 接收到消息后的处理函数
     返回值会自动被 await，然后可能被封装为 message 回传 */
 export type MessageHandler<TData = any> = (message: Message<TData>, remote: Remote) => void | any | Promise<void | any>;
@@ -102,6 +95,8 @@ export interface RemoteOptions {
     on_error?(error: WebSocketConnectionError | Error, remote: Remote): void;
     /** 使用者自定义的，在重连之前调用的函数，比如可以修改 url，仅连接发起方有效 */
     on_reconnect?(this: Remote): Promise<void>;
+    /** 使用者自定义的，在连接建立，包括首次连接和重连 之后调用的函数，比如可以重新调用一些函数，仅连接发起方有效 */
+    on_connected?(this: Remote): void;
 }
 /** 通过创建 remote 对象对 websocket rpc 进行抽象
     使用 remote.call() 进行一元 rpc
@@ -148,10 +143,11 @@ export declare class Remote {
     error: WebSocketConnectionError | Error;
     /** 作为 websocket 连接发起方，传入 url
         作为 websocket 连接接收方，传入 websocket + name */
-    constructor({ name, url, websocket, funcs, print, verbose, probe, args, on_error, on_reconnect }?: RemoteOptions);
+    constructor({ name, url, websocket, funcs, print, verbose, probe, args, on_error, on_reconnect, on_connected }?: RemoteOptions);
     /** 统一处理首次连接和连接后的 websocket 错误 */
     _on_error: (error: WebSocketConnectionError | Error) => void;
     on_reconnect?: (this: Remote) => Promise<void>;
+    on_connected?: (this: Remote) => void;
     reconnect: () => Promise<void>;
     _on_message: (data: ArrayBuffer) => void;
     /** 使用者自定义的在 websocket 连接出错时，或者 handlers 出错时的处理

package/net.common.js

@@ -1,7 +1,7 @@
 import { platform } from "./platform.common.js";
 import { rethrow } from "./prototype.common.js"; // .bracket()
 import { message_symbol, pack, parse } from "./io.common.js";
-import { check, defer, delay, genid, Lock, set_error_message, timeout, TimeoutError } from "./utils.common.js";
+import { check, defer, defer2, delay, genid, Lock, nowstr, set_error_message, timeout, TimeoutError } from "./utils.common.js";
 import { t } from "./i18n/instance.js";
 /** 对于 request() 函数来说无意义的 headers，会自动过滤掉 */
 export const drop_request_headers = new Set([
@@ -50,16 +50,7 @@ export class WebSocketConnectionError extends Error {
             if (event)
                 if ((type = event.type) === 'error') {
                     ({ error } = event);
-                    if (error) {
-                        ({ code, reason } = error);
-                        message = `${t('连接被关闭')}: ` + [
-                            error.message,
-                            WebSocketConnectionError.get_reason_string(code, reason),
-                            error.syscall ? `${error.syscall}(${error.errno})` : ''
-                        ].filter(Boolean).join(' ');
-                    }
-                    else
-                        message = t('连接被关闭');
+                    message = error ? `${t('连接被关闭')}: ${error.message}` : t('连接被关闭');
                 }
                 else {
                     ({ code, reason } = event);
@@ -67,7 +58,7 @@ export class WebSocketConnectionError extends Error {
                 }
             else
                 message = t('连接被关闭');
-        super(new Date().to_time_str() + '  ' +
+        super(nowstr() + '  ' +
             (url || '传入') +
             (protocols ? ' ' + protocols.join(', ').bracket() : '') +
             ' ' + message);
@@ -97,7 +88,9 @@ let websocket_proxy_agents = {};
     https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/bufferedAmount
     - url
     - options:
-        - print?: 是否打印连接、关闭信息
+        - print?: boolean 或者 ConnectWebSocketPrint，可以控制是否打印连接、正常断开、关闭信息
+            - connect: `true` 连接建立
+            - error: `true` 出错
         - protocols?
         - max_payload?: `8 gb` (仅 nodejs 环境有效)
         - proxy?: string (仅 nodejs 环境有效)
@@ -106,10 +99,21 @@ 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 */
-export async function connect_websocket(url, { print = true, protocols, max_payload = 2 ** 33, // 8 GB
-proxy, on_message, on_error, on_close, }) {
+            https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent#Status_codes
+        - connect?: nodejs 环境下需要指定 ip, port 手动连接 tls server 时使用，有 agent 时不生效 */
+export async function connect_websocket(url, { print = {
+    connect: true,
+    error: true,
+    close: true
+}, protocols, max_payload = 2 ** 33, // 8 GB
+proxy, on_message, on_error, on_close, connect }) {
     const { nodejs } = platform;
+    if (typeof print === 'boolean')
+        print = {
+            connect: print,
+            error: print,
+            close: print
+        };
     let websocket = new (await platform.get_websocket())(url, protocols, 
     // @ts-ignore
     nodejs ?
@@ -119,78 +123,60 @@ proxy, on_message, on_error, on_close, }) {
             allowSynchronousEvents: true,
             ...proxy ? {
                 agent: websocket_proxy_agents[proxy] ??= new (await platform.get_https_proxy_agent())(proxy)
-            } : {}
+            } : {},
+            ...connect ? { createConnection: connect } : {}
         }
         :
             undefined);
     // 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 error, close 事件只选一个最详细的构造 WebSocketConnectionError 并调用 on_error
-        let errored;
-        websocket.addEventListener('open', event => {
-            if (print)
-                console.log(websocket.url +
-                    (websocket.protocol ? ' ' + websocket.protocol.bracket() : '') +
-                    t(' 已连接'));
-            settled = true;
-            resolve(websocket);
-        }, { once: true });
-        // error 事件会先于 close 事件
-        // node.js 环境下 error 事件的错误信息比较多，浏览器环境下 close 的错误信息比较多
-        // 在浏览器环境下延后处理 error 事件，放到微任务队列之后的 timers 队列中
-        // https://blog.insiderattack.net/promises-next-ticks-and-immediates-nodejs-event-loop-part-3-9226cbe7a6aa
-        function on_close_or_error(event) {
-            websocket.removeEventListener('message', _on_message);
-            const { type } = event;
-            // 正常关闭
-            if (type === 'close' && event.code === 1000) {
-                if (on_close)
-                    on_close(event, websocket);
-                else if (print)
-                    console.log(`${websocket.url} 已正常关闭`);
-                return;
-            }
-            // 观察一段时间，在 nodejs 中应该没有先 close 再 error 的情况
-            if (errored === 'close' && platform.nodejs) {
-                console.warn('在 nodejs 中应该没有先 close 再 error 的情况', event.error);
-                errored = null;
-            }
-            // 已经调用过 on_error 了
-            if (errored)
-                return;
-            errored = type;
-            const error = new WebSocketConnectionError(websocket.url, protocols, event);
-            if (!settled) {
-                settled = true;
-                reject(error);
-                return;
-            }
-            if (on_error)
-                on_error(error, websocket);
-            else if (print)
-                console.log(error);
+    let pwebsocket = defer2();
+    websocket.addEventListener('open', event => {
+        if (print.connect)
+            console.log(websocket.url +
+                (websocket.protocol ? ' ' + websocket.protocol.bracket() : '') +
+                t(' 已连接'));
+        pwebsocket.resolve(websocket);
+    }, { once: true });
+    // websocket error, close 事件只选一个最详细的构造 WebSocketConnectionError 并调用 on_error
+    // error 事件会先于 close 事件
+    // node.js 环境下 error 事件的错误信息比较多，而浏览器环境下 close 的错误信息比较多
+    // 在浏览器环境下延后处理 error 事件，放到微任务队列之后的 timers 队列中
+    // https://blog.insiderattack.net/promises-next-ticks-and-immediates-nodejs-event-loop-part-3-9226cbe7a6aa
+    let errored;
+    function on_close_or_error(event) {
+        const { type } = event;
+        // 正常关闭
+        if (type === 'close' && event.code === 1000) {
+            if (on_close)
+                on_close(event, websocket);
+            else if (print.close)
+                console.log(`${websocket.url} ${t('已正常关闭')}`);
+            return;
         }
-        // 检查实际情况下 error 事件会先于 close 事件，观察一段时间后可删去
-        let closed = false;
-        websocket.addEventListener('error', (event) => {
-            if (closed)
-                console.warn('close 事件先于 error 事件发生，奇怪！');
-            if (nodejs)
-                on_close_or_error(event);
-            else
-                setTimeout(() => { on_close_or_error(event); });
-        }, { once: true });
-        websocket.addEventListener('close', event => {
-            closed = true;
+        // 已经调用过 on_error 了
+        if (errored)
+            return;
+        errored = type;
+        const error = new WebSocketConnectionError(websocket.url, protocols, event);
+        if (!pwebsocket.settled)
+            pwebsocket.reject(error);
+        else if (on_error)
+            on_error(error, websocket);
+        else if (print.error)
+            console.error(error.message);
+    }
+    websocket.addEventListener('error', (event) => {
+        if (nodejs)
             on_close_or_error(event);
-        }, { once: true });
-        function _on_message(event) {
-            on_message(event.data, websocket);
-        }
-        websocket.addEventListener('message', _on_message);
+        else
+            setTimeout(() => { on_close_or_error(event); });
+    }, { once: true });
+    websocket.addEventListener('close', on_close_or_error, { once: true });
+    websocket.addEventListener('message', event => {
+        on_message(event.data, websocket);
     });
+    return pwebsocket;
 }
 /** 通过创建 remote 对象对 websocket rpc 进行抽象
     使用 remote.call() 进行一元 rpc
@@ -238,7 +224,7 @@ export class Remote {
     error;
     /** 作为 websocket 连接发起方，传入 url
         作为 websocket 连接接收方，传入 websocket + name */
-    constructor({ name, url, websocket, funcs, print, verbose, probe, args, on_error, on_reconnect } = {}) {
+    constructor({ name, url, websocket, funcs, print, verbose, probe, args, on_error, on_reconnect, on_connected } = {}) {
         if (name)
             this.name = name;
         if (url) {
@@ -246,17 +232,19 @@ export class Remote {
             this.url = url;
             if (on_reconnect)
                 this.on_reconnect = on_reconnect;
+            if (on_connected)
+                this.on_connected = on_connected;
         }
         else { // 连接接收方，一定是 nodejs 环境
             check(websocket, '构建 Remote 时需传入 url 或者 websocket');
             this.lwebsocket.resource = websocket;
             websocket.binaryType = 'arraybuffer';
             // 参考 connect_websocket 实现
-            let errored = false;
+            let errored;
             const on_close_or_error = (event) => {
-                websocket.removeEventListener('message', _on_message);
+                const { type } = event;
                 // 正常关闭
-                if (event.type === 'close' && event.code === 1000) {
+                if (type === 'close' && event.code === 1000) {
                     if (print)
                         console.log(`${this.name || websocket.url || '传入连接'} 已正常关闭`);
                     return;
@@ -264,24 +252,14 @@ export class Remote {
                 // 已经调用过 on_error 了
                 if (errored)
                     return;
-                errored = true;
+                errored = type;
                 this._on_error(new WebSocketConnectionError(this.name || websocket.url, websocket.protocol ? [websocket.protocol] : undefined, event));
             };
-            // 检查实际情况下 error 事件会先于 close 事件，观察一段时间后可删去
-            let closed = false;
-            websocket.addEventListener('error', (event) => {
-                if (closed)
-                    console.warn('close 事件先于 error 事件发生，奇怪！');
-                on_close_or_error(event);
-            }, { once: true });
-            websocket.addEventListener('close', event => {
-                closed = true;
-                on_close_or_error(event);
-            }, { once: true });
-            const _on_message = (event) => {
+            websocket.addEventListener('error', on_close_or_error, { once: true });
+            websocket.addEventListener('close', on_close_or_error, { once: true });
+            websocket.addEventListener('message', event => {
                 this._on_message(event.data);
-            };
-            websocket.addEventListener('message', _on_message);
+            });
         }
         if (funcs) {
             check(!funcs.echo);
@@ -316,6 +294,7 @@ export class Remote {
         this.on_error(error, this);
     };
     on_reconnect;
+    on_connected;
     reconnect = async () => {
         this.reconnecting = null;
         if (this.on_reconnect)
@@ -389,6 +368,7 @@ export class Remote {
         this.error = null;
         if (this.args)
             await this.call('register', this.args);
+        this.on_connected?.();
     };
     /** 尝试建立连接，通常用于开始保活
         重连错误会在 this.connect 里面调用 this._on_error 处理 */

package/net.d.ts

@@ -2,7 +2,7 @@ import net from 'node:net';
 import { type Readable } from 'node:stream';
 import type { Cookie, CookieJar, MemoryCookieStore } from 'tough-cookie';
 import type { Encoding } from './file.ts';
-import { inspect, type Deferred2 } from './utils.ts';
+import { inspect, type Deferred2, type OnTimeout } from './utils.ts';
 import { type BasicAuth, type BearerAuth } from './net.common.ts';
 export * from './net.common.ts';
 export declare enum MyProxy {
@@ -111,7 +111,9 @@ export declare function request(url: string | URL, options: RequestOptions): Pro
 /** 发起 http 请求并将响应体作为 json 解析 */
 export declare function request_json<T = any>(url: string | URL, options?: RequestOptions): Promise<T>;
 export interface ConnectOptions {
+    local_port?: number;
     timeout?: number;
+    on_timeout?: OnTimeout;
     print?: {
         error: boolean;
         connect: boolean;
@@ -119,12 +121,14 @@ export interface ConnectOptions {
 }
 /** 建立 tcp 连接，超时时间为 2 秒 (timeout 选项)，返回已连接的 socket
     连接中遇到的错误会 reject，之后取消监听 error 事件，由调用者 attach 处理
+    连接超时则自动 socket.resetAndDestroy
     - hostname: 要连接到的 ip 或域名
     - port: 要连接的端口
     - options?:
+        - local_port?: `随机端口` 使用的本地端口
         - timeout?: `2000` 超时时间
         - print?: 打印连接日志，错误日志
             - error?: `true`
             - connect: `false` */
-export declare function connect(hostname: string, port: number, { timeout: _timeout, print }?: ConnectOptions): Deferred2<net.Socket>;
+export declare function connect(hostname: string, port: number, { local_port, timeout: _timeout, on_timeout, print }?: ConnectOptions): Deferred2<net.Socket>;
 export declare function get_socket_ip(socket: net.Socket): string;

package/net.js

@@ -3,7 +3,7 @@ import net from 'node:net';
 import { buffer as stream_to_buffer, text as stream_to_text } from 'node:stream/consumers';
 import { pipeline, isReadable } from 'node:stream';
 import { noop } from "./prototype.js";
-import { inspect, assert, delay, map_values, unique, timeout, check, colored, encode, TimeoutError, set_error_message, defer2 } from "./utils.js";
+import { inspect, assert, delay, map_values, unique, timeout, check, colored, encode, TimeoutError, set_error_message, defer2, nowstr } from "./utils.js";
 import { drop_request_headers } from "./net.common.js";
 export * from "./net.common.js";
 export var MyProxy;
@@ -295,22 +295,25 @@ export async function request_json(url, options) {
 }
 /** 建立 tcp 连接，超时时间为 2 秒 (timeout 选项)，返回已连接的 socket
     连接中遇到的错误会 reject，之后取消监听 error 事件，由调用者 attach 处理
+    连接超时则自动 socket.resetAndDestroy
     - hostname: 要连接到的 ip 或域名
     - port: 要连接的端口
     - options?:
+        - local_port?: `随机端口` 使用的本地端口
         - timeout?: `2000` 超时时间
         - print?: 打印连接日志，错误日志
             - error?: `true`
             - connect: `false` */
-export function connect(hostname, port, { timeout: _timeout = 2000, print = { error: true, connect: false } } = {}) {
+export function connect(hostname, port, { local_port, timeout: _timeout = 2000, on_timeout, print = { error: true, connect: false } } = {}) {
     let pconnected = defer2();
     let timeouted = false;
     function get_message(message) {
-        return `tcp://${hostname}:${port}  ${message}`;
+        return `${nowstr()}  tcp://${hostname}:${port}  ${message}`;
     }
     let socket = net.connect({
         host: hostname,
         port,
+        localPort: local_port,
         noDelay: true
     }, () => {
         if (pconnected.settled) {
@@ -341,11 +344,21 @@ export function connect(hostname, port, { timeout: _timeout = 2000, print = { er
         }
     };
     socket.once('error', on_error);
-    let timeout = setTimeout(() => {
+    let timeout = setTimeout(async () => {
         // 执行到这里一定没有 settled
         timeouted = true;
         socket.resetAndDestroy();
-        pconnected.reject(new TimeoutError(get_message('超时了')));
+        if (typeof on_timeout === 'function') {
+            pconnected.resolve(null);
+            try {
+                await on_timeout(new TimeoutError(get_message('超时了')));
+            }
+            catch (error) {
+                pconnected.reject(error);
+            }
+        }
+        else
+            pconnected.reject(new TimeoutError(on_timeout || get_message('超时了')));
     }, _timeout);
     return pconnected;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "xshell",
-    "version": "1.3.5",
+    "version": "1.3.7",
     "type": "module",
     "main": "./index.js",
     "bin": {
@@ -53,12 +53,12 @@
         "@babel/parser": "^7.28.5",
         "@babel/traverse": "^7.28.5",
         "@koa/cors": "^5.0.0",
-        "@stylistic/eslint-plugin": "^5.5.0",
+        "@stylistic/eslint-plugin": "^5.6.1",
         "@svgr/webpack": "^8.1.0",
         "@types/sass-loader": "^8.0.10",
-        "@typescript-eslint/eslint-plugin": "^8.46.3",
-        "@typescript-eslint/parser": "^8.46.3",
-        "@typescript-eslint/utils": "^8.46.3",
+        "@typescript-eslint/eslint-plugin": "^8.47.0",
+        "@typescript-eslint/parser": "^8.47.0",
+        "@typescript-eslint/utils": "^8.47.0",
         "archiver": "^7.0.1",
         "chalk": "^5.6.2",
         "commander": "^14.0.2",
@@ -68,17 +68,17 @@
         "eslint-plugin-import": "^2.32.0",
         "eslint-plugin-react": "^7.37.5",
         "https-proxy-agent": "^7.0.6",
-        "i18next": "^25.6.1",
+        "i18next": "^25.6.3",
         "i18next-scanner": "^4.6.0",
         "koa": "^3.1.1",
         "koa-compress": "^5.1.1",
         "license-webpack-plugin": "^4.0.2",
         "mime-types": "^3.0.1",
-        "p-map": "^7.0.3",
+        "p-map": "^7.0.4",
         "react": "^19.2.0",
-        "react-i18next": "^16.2.4",
+        "react-i18next": "^16.3.4",
         "resolve-path": "^1.4.0",
-        "sass": "^1.93.3",
+        "sass": "^1.94.1",
         "sass-loader": "^16.0.6",
         "source-map-loader": "^5.0.0",
         "strip-ansi": "^7.1.2",
@@ -88,8 +88,8 @@
         "tslib": "^2.8.1",
         "typescript": "^5.9.3",
         "undici": "^7.16.0",
-        "webpack": "^5.102.1",
-        "webpack-bundle-analyzer": "^4.10.2",
+        "webpack": "^5.103.0",
+        "webpack-bundle-analyzer": "^5.0.1",
         "ws": "^8.18.3"
     },
     "devDependencies": {
@@ -101,10 +101,10 @@
         "@types/koa": "^3.0.1",
         "@types/koa-compress": "^4.0.7",
         "@types/mime-types": "^3.0.1",
-        "@types/node": "^24.10.0",
-        "@types/react": "^19.2.2",
+        "@types/node": "^24.10.1",
+        "@types/react": "^19.2.6",
         "@types/tough-cookie": "^4.0.5",
-        "@types/vscode": "^1.105.0",
+        "@types/vscode": "^1.106.1",
         "@types/webpack-bundle-analyzer": "^4.7.0",
         "@types/ws": "^8.18.1"
     }

package/utils.common.d.ts

@@ -63,6 +63,7 @@ export declare function decode(buffer: Uint8Array): string;
 /** 比较两个 buffer 内容是否相同，第二个可以传入 string 自动编码转换后比较，
     高频调用时建议提前编码 right 并缓存 */
 export declare function buffer_equals(left: Uint8Array, right: Uint8Array | string): boolean;
+export type OnTimeout = string | ((error: TimeoutError) => void | Promise<void>);
 /** 在指定的时间 (milliseconds) 内运行某个任务，超时之后抛出错误或调用 on_timeout
     - milliseconds: 限时毫秒数
     - action?: 要等待运行的任务, async function 或 promise
@@ -74,7 +75,7 @@ export declare function buffer_equals(left: Uint8Array, right: Uint8Array | stri
                 - on_timeout 报错: timeout 函数最终抛出这个错误
         - 若不传: 直接抛出 TimeoutError
     - print?: `true` 打印已超时任务的错误 */
-export declare function timeout<TReturn>(milliseconds: number, action: Promise<TReturn> | (() => Promise<TReturn>), on_timeout?: string | ((error: TimeoutError) => void | Promise<void>), print?: boolean): Deferred2<TReturn>;
+export declare function timeout<TReturn>(milliseconds: number, action: Promise<TReturn> | (() => Promise<TReturn>), on_timeout?: OnTimeout, print?: boolean): Deferred2<TReturn>;
 /** 轮询尝试 action 共 times 次，每次间隔 duration
     action 返回 trusy 值时认为成功，返回 action 的结果
     如果次数用尽仍然失败，返回 null */

package/utils.common.js

@@ -215,7 +215,7 @@ export function timeout(milliseconds, action, on_timeout, print = true) {
     paction.then(result => {
         if (presult.settled) {
             if (print)
-                console.log('已超时任务最终完成了');
+                console.log('已超时任务最终完成了:', result);
         }
         else if (!waiting_on_timeout) {
             presult.resolve(result);

package/utils.js

@@ -31,14 +31,14 @@ export function typed_array_to_buffer(view) {
     - hour: 0 - 23 之间的整数，在这个点执行
     - action */
 export async function schedule_everyday(hour, action) {
-    const now = new Date();
+    const now = Date.now();
     let target = new Date();
     target.setHours(hour, 0, 0, 0);
     // 如果目标时间已过，设定为明天的时间
-    if (now.getTime() > target.getTime())
+    if (now > target.getTime())
         target.setDate(target.getDate() + 1);
     // 等时间到
-    await delay(target.getTime() - now.getTime());
+    await delay(target.getTime() - now);
     for (;;) {
         try {
             await action();