xshell 1.3.8 → 1.3.10

package/builder.js

@@ -79,18 +79,6 @@ const dependencies = {
         assets: {
             productions: ['monaco-editor/min/vs/'],
             devs: ['monaco-editor/dev/vs/']
-        },
-        maps: {
-            productions: [
-                'monaco-editor/min-maps/vs/base/worker/workerMain.js.map',
-                'monaco-editor/min-maps/vs/editor/editor.main.js.map',
-                'monaco-editor/min-maps/vs/loader.js.map',
-                'monaco-editor/min-maps/nls.messages.zh-cn.js.map',
-            ],
-            devs: [
-                'monaco-editor/dev/vs/base/worker/workerMain.js.map',
-                'monaco-editor/dev/vs/editor/editor.main.js.map',
-            ],
         }
     },
     echarts: {

package/file.d.ts

@@ -207,13 +207,13 @@ export interface FMkdirOptions {
         - print?: `true` */
 export declare function fmkdir(fpd: string, { print }?: FMkdirOptions): Promise<string>;
 /** 创建软链接
-    - fp_real: 现在真实文件/文件夹的路径
-    - fp_link: 目标链接文件/文件夹的路径
+    - fp_link: 创建的链接的路径
+    - fp_real: 真实目标文件/文件夹的路径
     - options?:
         - skip_existing?: `false` 忽略已存在的同名的文件，文件夹
         - print?: `true`
         - junction? */
-export declare function flink(fp_real: string, fp_link: string, { skip_existing, print, junction }?: {
+export declare function flink(fp_link: string, fp_real: string, { skip_existing, print, junction }?: {
     skip_existing?: boolean;
     print?: boolean;
     junction?: boolean;

package/file.js

@@ -455,13 +455,13 @@ export async function fmkdir(fpd, { print = true } = {}) {
     return fpd_;
 }
 /** 创建软链接
-    - fp_real: 现在真实文件/文件夹的路径
-    - fp_link: 目标链接文件/文件夹的路径
+    - fp_link: 创建的链接的路径
+    - fp_real: 真实目标文件/文件夹的路径
     - options?:
         - skip_existing?: `false` 忽略已存在的同名的文件，文件夹
         - print?: `true`
         - junction? */
-export async function flink(fp_real, fp_link, { skip_existing = false, print = true, junction = false } = {}) {
+export async function flink(fp_link, fp_real, { skip_existing = false, print = true, junction = false } = {}) {
     check(path.isAbsolute(fp_real) && path.isAbsolute(fp_link), 'fp 必须是绝对路径');
     const is_fpd_real = fp_real.isdir;
     const is_fpd_link = fp_link.isdir;
@@ -475,7 +475,7 @@ export async function flink(fp_real, fp_link, { skip_existing = false, print = t
             return;
         }
     if (print)
-        log_action('已将源文件', fp_real, fp_link, '链接到');
+        log_action('创建链接', fp_link, fp_real);
     if (junction)
         await fsp.symlink(fp_real, fp_link, 'junction');
     else

package/net.common.d.ts

@@ -1,5 +1,11 @@
+import type { Socket } from 'node:net';
 import { type Message } from './io.common.ts';
 import { Lock, TimeoutError } from './utils.common.ts';
+declare global {
+    interface WebSocket {
+        _socket?: Socket;
+    }
+}
 /** 对于 request() 函数来说无意义的 headers，会自动过滤掉 */
 export declare const drop_request_headers: Set<string>;
 export interface BasicAuth {
@@ -42,6 +48,7 @@ export interface ConnectWebsocketOptions {
     protocols?: string[];
     max_payload?: number;
     proxy?: string;
+    keep_alive_duration?: number;
     on_message(data: ArrayBuffer | string, websocket: WebSocket): any;
     on_error?(error: WebSocketConnectionError, websocket: WebSocket): any;
     on_close?(event: CloseEvent, websocket: WebSocket): any;
@@ -61,6 +68,7 @@ export interface ConnectWebsocketOptions {
         - protocols?
         - max_payload?: `8 gb` (仅 nodejs 环境有效)
         - proxy?: string (仅 nodejs 环境有效)
+        - keep_alive_duration?: 毫秒数，设置后启用操作系统级的 keep alive (仅 nodejs 环境可以有效，浏览器端默认已启用)
         - on_message: 根据 websocket frame 的 opcode 不同 (text frame 或 binary frame)，event 中的 data 对应为 ArrayBuffer 或者 string
           https://datatracker.ietf.org/doc/html/rfc6455#section-5.2
         - on_error?: 在 websocket 出错和非正常关闭 (close, error 事件) 时都调用，可以根据 error.type 来区分，error 的类型是 WebSocketConnectionError，
@@ -69,7 +77,7 @@ export interface ConnectWebsocketOptions {
             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, connect }: ConnectWebsocketOptions): Promise<WebSocket>;
+proxy, keep_alive_duration, 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>;
@@ -82,8 +90,12 @@ export interface RemoteOptions {
     websocket?: WebSocket;
     /** 能被对端调用的函数 */
     funcs?: Remote['funcs'];
-    /** `false` 是否启用主动探测连接，在连接状态下以 30s 间隔发送心跳包确保连接状态 */
-    probe?: boolean;
+    /** 设置后启用操作系统级的 keep alive (仅 nodejs 环境可设置)
+        - 浏览器端有默认 tcp keep alive 心跳机制，禁止设置这个参数
+        - nodejs 端
+            - 作为连接发起方: 在 websocket 连接建立时启用
+            - 作为连接接收方: 在根据传入 websocket 创建 Remote 时启用 */
+    alive?: boolean;
     /** websocket 连接建立成功时调用对端 register 函数的参数 (仅发起方有效) */
     args?: any[];
     /** `true` 是否打印连接信息、错误信息 */
@@ -95,7 +107,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 进行抽象
@@ -120,8 +133,8 @@ export declare class Remote {
     url?: string;
     /** 能被对端调用的函数 */
     funcs: Record<string, MessageHandler>;
-    /** `false` 是否启用主动探测连接，在连接状态下以 30s 间隔发送心跳包确保连接状态 */
-    probe: boolean;
+    /** tcp keep alive */
+    alive: boolean;
     /** websocket 连接建立成功时调用对端 register 函数的参数 (仅发起方有效) */
     args?: any[];
     /** `true` 是否打印连接信息、错误信息 */
@@ -133,8 +146,6 @@ export declare class Remote {
     /** map<id, message handler>: 通过 (rpc message).id 找到对应的 handler
         一元 rpc 接收方不需要设置 handlers, 发送方需要 */
     handlers: Map<number, MessageHandler<any>>;
-    /** 是否正在定时主动检测重连 */
-    probing: boolean;
     /** websocket 检测到错误，_on_error 被调用，此时会尝试一段时间后重连 */
     reconnecting: NodeJS.Timeout;
     /** 用户是否手动调用了 disconnect() 主动断开了连接 (仅发起方有效) */
@@ -143,7 +154,7 @@ 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, on_connected }?: RemoteOptions);
+    constructor({ name, url, websocket, funcs, print, verbose, alive, args, on_error, on_reconnect, on_connected }?: RemoteOptions);
     /** 统一处理首次连接和连接后的 websocket 错误 */
     _on_error: (error: WebSocketConnectionError | Error) => void;
     on_reconnect?: (this: Remote) => Promise<void>;
@@ -168,13 +179,13 @@ export declare class Remote {
     /** 尝试建立连接，通常用于开始保活
         重连错误会在 this.connect 里面调用 this._on_error 处理 */
     try_connect(): Promise<void>;
-    /** 开始心跳保活 */
-    probe_connection(print_timeout?: boolean): Promise<void>;
     /** 检测连接，返回连接错误，出错时触发 on_error 打印错误信息
         返回值:
         - 连接正常返回: undefined
         - 连接错误返回: 实际的连接错误，通常是 WebSocketConnectionError | TimeoutError */
     test(print_timeout?: boolean): Promise<WebSocketConnectionError | TimeoutError | Error>;
+    /** node.js 下连接接收方在 Remote 创建后手动启用 tcp keep alive */
+    keep_alive(): void;
     /** 手动关闭到对端的 websocket 连接 */
     disconnect(): void;
     /** 发送 message 到对端 remote

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, defer2, delay, genid, Lock, nowstr, set_error_message, timeout, TimeoutError } from "./utils.common.js";
+import { check, defer, defer2, 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([
@@ -94,6 +94,7 @@ let websocket_proxy_agents = {};
         - protocols?
         - max_payload?: `8 gb` (仅 nodejs 环境有效)
         - proxy?: string (仅 nodejs 环境有效)
+        - keep_alive_duration?: 毫秒数，设置后启用操作系统级的 keep alive (仅 nodejs 环境可以有效，浏览器端默认已启用)
         - on_message: 根据 websocket frame 的 opcode 不同 (text frame 或 binary frame)，event 中的 data 对应为 ArrayBuffer 或者 string
           https://datatracker.ietf.org/doc/html/rfc6455#section-5.2
         - on_error?: 在 websocket 出错和非正常关闭 (close, error 事件) 时都调用，可以根据 error.type 来区分，error 的类型是 WebSocketConnectionError，
@@ -106,7 +107,7 @@ export async function connect_websocket(url, { print = {
     error: true,
     close: true
 }, protocols, max_payload = 2 ** 33, // 8 GB
-proxy, on_message, on_error, on_close, connect }) {
+proxy, keep_alive_duration, on_message, on_error, on_close, connect }) {
     const { nodejs } = platform;
     if (typeof print === 'boolean')
         print = {
@@ -114,6 +115,8 @@ proxy, on_message, on_error, on_close, connect }) {
             error: print,
             close: print
         };
+    if (keep_alive_duration)
+        check(nodejs, 'keep_alive_duration 仅 nodejs 环境有效');
     let websocket = new (await platform.get_websocket())(url, protocols, 
     // @ts-ignore
     nodejs ?
@@ -136,6 +139,8 @@ proxy, on_message, on_error, on_close, connect }) {
             console.log(websocket.url +
                 (websocket.protocol ? ' ' + websocket.protocol.bracket() : '') +
                 t(' 已连接'));
+        if (keep_alive_duration)
+            websocket._socket.setKeepAlive(true, keep_alive_duration);
         pwebsocket.resolve(websocket);
     }, { once: true });
     // websocket error, close 事件只选一个最详细的构造 WebSocketConnectionError 并调用 on_error
@@ -200,8 +205,8 @@ export class Remote {
     url;
     /** 能被对端调用的函数 */
     funcs;
-    /** `false` 是否启用主动探测连接，在连接状态下以 30s 间隔发送心跳包确保连接状态 */
-    probe = false;
+    /** tcp keep alive */
+    alive = false;
     /** websocket 连接建立成功时调用对端 register 函数的参数 (仅发起方有效) */
     args;
     /** `true` 是否打印连接信息、错误信息 */
@@ -214,8 +219,6 @@ export class Remote {
     /** map<id, message handler>: 通过 (rpc message).id 找到对应的 handler
         一元 rpc 接收方不需要设置 handlers, 发送方需要 */
     handlers = new Map();
-    /** 是否正在定时主动检测重连 */
-    probing = false;
     /** websocket 检测到错误，_on_error 被调用，此时会尝试一段时间后重连 */
     reconnecting;
     /** 用户是否手动调用了 disconnect() 主动断开了连接 (仅发起方有效) */
@@ -224,9 +227,13 @@ export class Remote {
     error;
     /** 作为 websocket 连接发起方，传入 url
         作为 websocket 连接接收方，传入 websocket + name */
-    constructor({ name, url, websocket, funcs, print, verbose, probe, args, on_error, on_reconnect, on_connected } = {}) {
+    constructor({ name, url, websocket, funcs, print, verbose, alive, args, on_error, on_reconnect, on_connected } = {}) {
         if (name)
             this.name = name;
+        if (alive) {
+            check(!platform.browser, '浏览器端有默认 tcp keep alive 心跳机制，禁止设置 alive 选项');
+            this.alive = true;
+        }
         if (url) {
             check(!websocket, '构建 Remote 时 url 和 websocket 只能传其中一个');
             this.url = url;
@@ -237,8 +244,10 @@ export class Remote {
         }
         else { // 连接接收方，一定是 nodejs 环境
             check(websocket, '构建 Remote 时需传入 url 或者 websocket');
-            this.lwebsocket.resource = websocket;
             websocket.binaryType = 'arraybuffer';
+            if (this.alive)
+                websocket._socket.setKeepAlive(true, 30_000);
+            this.lwebsocket.resource = websocket;
             // 参考 connect_websocket 实现
             let errored;
             const on_close_or_error = (event) => {
@@ -265,8 +274,6 @@ export class Remote {
             check(!funcs.echo);
             this.funcs = funcs;
         }
-        if (probe !== undefined)
-            this.probe = probe;
         if (args)
             this.args = args;
         if (print !== undefined)
@@ -287,7 +294,7 @@ export class Remote {
         if (error instanceof WebSocketConnectionError &&
             !this.reconnecting &&
             this.url &&
-            (this.funcs || this.probe)) {
+            this.funcs) {
             this.reconnecting = setTimeout(this.reconnect, this.error ? 20_000 : 2_000);
             this.error = error;
         }
@@ -335,9 +342,6 @@ export class Remote {
     async connect() {
         if (this.disconnected)
             throw new Error(`remote (${this.name || this.url}) 已调用过 disconnect 断开连接，无法再次 connect`);
-        // 首次 connect 开始探测
-        if (this.probe && !this.probing)
-            this.probe_connection();
         if (this.check_connection())
             return;
         try {
@@ -363,7 +367,8 @@ export class Remote {
         this.lwebsocket.resource = await connect_websocket(this.url, {
             on_message: this._on_message,
             on_error: this._on_error,
-            print: this.print
+            print: this.print,
+            keep_alive_duration: this.alive ? 30_000 : undefined
         });
         this.error = null;
         if (this.args)
@@ -378,21 +383,6 @@ export class Remote {
         }
         catch { }
     }
-    /** 开始心跳保活 */
-    async probe_connection(print_timeout = true) {
-        // 手动调用该函数时也会启用 probe
-        this.probe = true;
-        this.probing = true;
-        for (let timeouted = false;;) {
-            await delay(timeouted ? 5_000 : 30_000);
-            if (this.disconnected || !this.url && !this.check_connection() || !this.probe)
-                break;
-            if (this.reconnecting)
-                continue;
-            // 产生的非 TimeoutError 应该都通过 _on_error 输出了，同时可能触发了重连
-            timeouted = (await this.test(print_timeout)) instanceof TimeoutError;
-        }
-    }
     /** 检测连接，返回连接错误，出错时触发 on_error 打印错误信息
         返回值:
         - 连接正常返回: undefined
@@ -416,6 +406,12 @@ export class Remote {
             return error;
         }
     }
+    /** node.js 下连接接收方在 Remote 创建后手动启用 tcp keep alive */
+    keep_alive() {
+        check(!this.url && platform.nodejs);
+        this.alive = true;
+        this.lwebsocket.resource?._socket.setKeepAlive(true, 30_000);
+    }
     /** 手动关闭到对端的 websocket 连接 */
     disconnect() {
         this.disconnected = true;

package/net.d.ts

@@ -114,6 +114,7 @@ export interface ConnectOptions {
     local_port?: number;
     timeout?: number;
     on_timeout?: OnTimeout;
+    keep_alive_duration?: number;
     print?: {
         error: boolean;
         connect: boolean;
@@ -127,8 +128,9 @@ export interface ConnectOptions {
     - options?:
         - local_port?: `随机端口` 使用的本地端口
         - timeout?: `2000` 超时时间
+        - keep_alive_duration?: 毫秒数，设置后启用操作系统级的 keep alive
         - print?: 打印连接日志，错误日志
             - error?: `true`
             - connect: `false` */
-export declare function connect(hostname: string, port: number, { local_port, timeout: _timeout, on_timeout, print }?: ConnectOptions): Deferred2<net.Socket>;
+export declare function connect(hostname: string, port: number, { local_port, timeout: _timeout, on_timeout, keep_alive_duration, print }?: ConnectOptions): Deferred2<net.Socket>;
 export declare function get_socket_ip(socket: net.Socket): string;

package/net.js

@@ -301,31 +301,37 @@ export async function request_json(url, options) {
     - options?:
         - local_port?: `随机端口` 使用的本地端口
         - timeout?: `2000` 超时时间
+        - keep_alive_duration?: 毫秒数，设置后启用操作系统级的 keep alive
         - print?: 打印连接日志，错误日志
             - error?: `true`
             - connect: `false` */
-export function connect(hostname, port, { local_port, timeout: _timeout = 2000, on_timeout, print = { error: true, connect: false } } = {}) {
+export function connect(hostname, port, { local_port, timeout: _timeout = 2000, on_timeout, keep_alive_duration, print = { error: true, connect: false } } = {}) {
     let pconnected = defer2();
     let timeouted = false;
-    function get_message(message) {
-        return `${nowstr()}  tcp://${hostname}:${port}  ${message}`;
+    function get_log_message(message) {
+        return `${nowstr()}  ${get_error_message(message)}`;
+    }
+    function get_error_message(message) {
+        return `tcp://${hostname}:${port}  ${message}`;
     }
     let socket = net.connect({
         host: hostname,
         port,
         localPort: local_port,
-        noDelay: true
+        noDelay: true,
+        keepAlive: Boolean(keep_alive_duration),
+        keepAliveInitialDelay: keep_alive_duration
     }, () => {
         if (pconnected.settled) {
             if (print)
-                console.warn(get_message('连接建立了，但是已超时'.yellow));
+                console.warn(get_log_message('连接建立了，但是已超时'.yellow));
             socket.resetAndDestroy();
         }
         else {
             clearTimeout(timeout);
             socket.off('error', on_error);
             if (print.connect)
-                console.log(get_message('已连接'));
+                console.log(get_log_message('已连接'));
             pconnected.resolve(socket);
         }
     });
@@ -336,11 +342,11 @@ export function connect(hostname, port, { local_port, timeout: _timeout = 2000,
                 return;
             // 待观察：不太可能走到这里
             if (print.error)
-                console.error(get_message(error.message.red));
+                console.error(get_log_message(error.message.red));
         }
         else {
             clearTimeout(timeout);
-            pconnected.reject(set_error_message(error, get_message(error.message)));
+            pconnected.reject(set_error_message(error, get_error_message(error.message)));
         }
     };
     socket.once('error', on_error);
@@ -351,14 +357,14 @@ export function connect(hostname, port, { local_port, timeout: _timeout = 2000,
         if (typeof on_timeout === 'function') {
             pconnected.resolve(null);
             try {
-                await on_timeout(new TimeoutError(get_message('超时了')));
+                await on_timeout(new TimeoutError(get_error_message('超时了')));
             }
             catch (error) {
                 pconnected.reject(error);
             }
         }
         else
-            pconnected.reject(new TimeoutError(on_timeout || get_message('超时了')));
+            pconnected.reject(new TimeoutError(on_timeout || get_error_message('超时了')));
     }, _timeout);
     return pconnected;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "xshell",
-    "version": "1.3.8",
+    "version": "1.3.10",
     "type": "module",
     "main": "./index.js",
     "bin": {
@@ -56,9 +56,9 @@
         "@stylistic/eslint-plugin": "^5.6.1",
         "@svgr/webpack": "^8.1.0",
         "@types/sass-loader": "^8.0.10",
-        "@typescript-eslint/eslint-plugin": "^8.47.0",
-        "@typescript-eslint/parser": "^8.47.0",
-        "@typescript-eslint/utils": "^8.47.0",
+        "@typescript-eslint/eslint-plugin": "^8.48.0",
+        "@typescript-eslint/parser": "^8.48.0",
+        "@typescript-eslint/utils": "^8.48.0",
         "archiver": "^7.0.1",
         "chalk": "^5.6.2",
         "commander": "^14.0.2",
@@ -73,12 +73,12 @@
         "koa": "^3.1.1",
         "koa-compress": "^5.1.1",
         "license-webpack-plugin": "^4.0.2",
-        "mime-types": "^3.0.1",
+        "mime-types": "^3.0.2",
         "p-map": "^7.0.4",
         "react": "^19.2.0",
-        "react-i18next": "^16.3.4",
+        "react-i18next": "^16.3.5",
         "resolve-path": "^1.4.0",
-        "sass": "^1.94.1",
+        "sass": "^1.94.2",
         "sass-loader": "^16.0.6",
         "source-map-loader": "^5.0.0",
         "strip-ansi": "^7.1.2",
@@ -88,7 +88,7 @@
         "tslib": "^2.8.1",
         "typescript": "^5.9.3",
         "undici": "^7.16.0",
-        "webpack": "^5.103.0",
+        "webpack": "5.101.0",
         "webpack-bundle-analyzer": "^5.0.1",
         "ws": "^8.18.3"
     },
@@ -102,7 +102,7 @@
         "@types/koa-compress": "^4.0.7",
         "@types/mime-types": "^3.0.1",
         "@types/node": "^24.10.1",
-        "@types/react": "^19.2.6",
+        "@types/react": "^19.2.7",
         "@types/tough-cookie": "^4.0.5",
         "@types/vscode": "^1.106.1",
         "@types/webpack-bundle-analyzer": "^4.7.0",

package/path.d.ts

@@ -54,7 +54,7 @@ export declare function extname(path: string): string;
 /** `/` */
 export declare const sep = "/";
 /** The platform-specific file delimiter. ';' or ':'. */
-export declare const delimiter: ":" | ";";
+export declare const delimiter: ";" | ":";
 /** Returns an object from a path string - the opposite of format().
     @param path path to evaluate.
     @throws {TypeError} if `path` is not a string. */
@@ -81,7 +81,7 @@ export declare let path: {
     basename: typeof basename;
     extname: typeof extname;
     sep: string;
-    delimiter: ":" | ";";
+    delimiter: ";" | ":";
     parse: typeof parse;
     format: typeof format;
     toNamespacedPath: typeof toNamespacedPath;