xshell 1.2.71 → 1.2.73

package/file.d.ts

@@ -78,6 +78,7 @@ export declare function fequals(fp_left: string, fp_right: string, { print }?: {
 export interface FWriteOptions {
     print?: boolean;
     mtime?: number;
+    flush?: boolean;
 }
 /** 写入 data 到 fp 路径或句柄所指的文件
     会在因不存在父文件夹导致写入失败时，自动创建父文件夹，并再次尝试写入
@@ -90,7 +91,8 @@ export interface FWriteOptions {
         - any: 通过 JSON.stringify 转为文本后写入文件
     - options?:
         - print?: `true`
-        - mtime?: 在写入后设置修改时间 (utc 毫秒数) */
+        - mtime?: 在写入后设置修改时间 (utc 毫秒数)
+        - flush?: 用 filehandle.sync() 刷到硬盘，确保已写入 */
 export declare function fwrite(fp: string, data: string | Uint8Array | any, options?: FWriteOptions): Promise<string>;
 export declare function fwrite(fp: FileHandle, data: string | Uint8Array | any, options?: FWriteOptions): Promise<FileHandle>;
 export declare function fwrite(fp: string | FileHandle, data: string | Uint8Array | any, options?: FWriteOptions): Promise<string | FileHandle>;

package/file.js

@@ -2,7 +2,7 @@ import { promises as fsp, default as fs } from 'fs';
 import { isArrayBuffer, isUint8Array } from 'util/types';
 import { t } from "./i18n/instance.js";
 import { noop, to_json } from "./prototype.js";
-import { pack, parse } from "./io.js";
+import { pack, parse } from "./io.common.js";
 import { path } from "./path.js";
 import { check, Lock, WritableMemoryStream, url_width, throttle, decode, strcmp } from "./utils.js";
 import { noprint } from "./process.js";
@@ -87,7 +87,7 @@ export async function fequals(fp_left, fp_right, { print = true } = {}) {
         return false;
     }
 }
-export async function fwrite(fp, data, { print = true, mtime } = {}) {
+export async function fwrite(fp, data, { print = true, mtime, flush } = {}) {
     const is_handle = typeof fp === 'object' && fp && 'fd' in fp;
     if (is_handle) {
         if (print)
@@ -113,13 +113,14 @@ export async function fwrite(fp, data, { print = true, mtime } = {}) {
         }
         return fp;
     }
+    const write_options = { flush };
     try {
-        await fsp.writeFile(fp, data);
+        await fsp.writeFile(fp, data, write_options);
     }
     catch (error) {
         if (error.code === 'ENOENT' && !is_handle) {
             await fmkdir(fp.fdir, noprint);
-            await fsp.writeFile(fp, data);
+            await fsp.writeFile(fp, data, write_options);
         }
         else
             throw error;

package/index.d.ts

@@ -1,5 +1,5 @@
 export * from './prototype.ts';
-export * from './io.ts';
+export * from './io.common.ts';
 export * from './utils.ts';
 export * from './file.ts';
 export * from './process.ts';

package/index.js

@@ -1,5 +1,5 @@
 export * from "./prototype.js";
-export * from "./io.js";
+export * from "./io.common.js";
 export * from "./utils.js";
 export * from "./file.js";
 export * from "./process.js";

package/{io.d.ts → io.common.d.ts}

@@ -1,4 +1,4 @@
-import './prototype.ts';
+import './prototype.common.ts';
 /** 二进制消息格式, 按 key 的顺序序列化值 */
 export interface Message<TData = any> {
     /** rpc id: 在 rpc 系统中认为是唯一的。用来在单个 websocket 连接上同时进行多个 rpc 请求。

package/{io.browser.js → io.common.js}

@@ -1,5 +1,5 @@
-import "./prototype.browser.js";
-import { decode, encode_into, ceil2, seq } from "./utils.browser.js";
+import "./prototype.common.js";
+import { decode, encode_into, ceil2, seq } from "./utils.common.js";
 // 类型            | 编码
 // --------------- | -------------------
 // small int +     | 0x00 - 0x1f (0 - 31 自然数)
@@ -51,7 +51,7 @@ let dv = buf.dataview;
 let p = 0;
 // --- 编码
 /** 编码缓冲区，持续往里写入，满了就用一个两倍大小的替换，将旧的未写完的部分复制过来 */
-let buffer = new Uint8Array(8 * 2 ** 20);
+let buffer = new Uint8Array(8 * 2 ** 20 /* Buffer.poolSize */);
 /** 编码缓冲区对应的 dataview */
 let dataview = buffer.dataview;
 /** 指针，编码缓冲区可以写入的位置，只增不减，除非换新 buffer */
@@ -132,7 +132,7 @@ function _parse() {
         case 0xcc: {
             const values = _parse();
             let message = {};
-            for (let i = 0; i < values.length; i++)
+            for (let i = 0; i < values.length; ++i)
                 message[message_keys[i]] = values[i];
             return message;
         }
@@ -191,19 +191,19 @@ function parse_string(len) {
 }
 function parse_array(len) {
     let a = new Array(len);
-    for (let i = 0; i < len; i++)
+    for (let i = 0; i < len; ++i)
         a[i] = _parse();
     return a;
 }
 function parse_set(size) {
     let s = new Set();
-    for (let i = 0; i < size; i++)
+    for (let i = 0; i < size; ++i)
         s.add(_parse());
     return s;
 }
 function parse_object(nentries) {
     let o = {};
-    for (let i = 0; i < nentries; i++) {
+    for (let i = 0; i < nentries; ++i) {
         const key = _parse();
         o[key] = _parse();
     }
@@ -211,7 +211,7 @@ function parse_object(nentries) {
 }
 function parse_map(nentries) {
     let map = new Map();
-    for (let i = 0; i < nentries; i++)
+    for (let i = 0; i < nentries; ++i)
         map.set(_parse(), _parse());
     return map;
 }
@@ -357,7 +357,7 @@ function _pack(value) {
                     dataview.setUint32(q, length, true);
                     q += 4;
                 }
-                for (let i = 0; i < length; i++)
+                for (let i = 0; i < length; ++i)
                     _pack(value[i]);
             }
             else if (value instanceof Uint8Array) {
@@ -509,7 +509,7 @@ function pack_string(value, qstr) {
     const { length } = value;
     if (length <= 0x3f) {
         let j = qstr;
-        for (let i = 0; i < length; i++) {
+        for (let i = 0; i < length; ++i) {
             let c1 = value.charCodeAt(i), c2 = 0;
             if (c1 < 0x80)
                 buffer[j++] = c1;
@@ -519,7 +519,7 @@ function pack_string(value, qstr) {
             }
             else if ((c1 & 0xfc00) === 0xd800 && ((c2 = value.charCodeAt(i + 1)) & 0xfc00) === 0xdc00) {
                 c1 = 0x10000 + ((c1 & 0x03ff) << 10) + (c2 & 0x03ff);
-                i++;
+                ++i;
                 buffer[j++] = (c1 >> 18) | 0xf0;
                 buffer[j++] = ((c1 >> 12) & 0x3f) | 0x80;
                 buffer[j++] = ((c1 >> 6) & 0x3f) | 0x80;
@@ -537,4 +537,4 @@ function pack_string(value, qstr) {
         return encode_into(value, buffer.subarray(qstr))
             .written;
 }
-//# sourceMappingURL=io.browser.js.map
+//# sourceMappingURL=io.common.js.map

package/net.browser.d.ts

@@ -1,4 +1,4 @@
-import { type Message } from './io.browser.ts';
+import { type Message } from './io.common.ts';
 import { Lock } from './utils.browser.ts';
 import { type BasicAuth, type BearerAuth, type RemoteKeeperOptions } from './net.common.ts';
 export * from './net.common.ts';

package/net.browser.js

@@ -1,6 +1,6 @@
 import { t } from "./i18n/instance.js";
 import { rethrow } from "./prototype.browser.js"; // to_time_str()
-import { message_symbol, pack, parse } from "./io.browser.js";
+import { message_symbol, pack, parse } from "./io.common.js";
 import { assert, genid, delay, Lock, timeout, check } from "./utils.browser.js";
 import { drop_request_headers } from "./net.common.js";
 export * from "./net.common.js";
@@ -131,14 +131,14 @@ export async function request(url, options = {}) {
 }
 /** 发起 http 请求并将响应体作为 json 解析 */
 export async function request_json(url, options) {
-    const resp = await request(url, options);
-    if (!resp)
+    const body = await request(url, options);
+    if (!body)
         return;
     try {
-        return JSON.parse(resp);
+        return JSON.parse(body);
     }
     catch (error) {
-        console.error(resp);
+        console.error(body);
         throw error;
     }
 }
@@ -355,62 +355,62 @@ export class Remote {
         作为 websocket 连接发起方，不需要传入 websocket
         作为 websocket 连接接收方，需要传入使用的 websocket 连接，确保这个这个连接的状态 */
     async connect(websocket) {
-        if (this.initiator)
-            if (this.lwebsocket.resource?.readyState === WebSocket.OPEN)
+        if (!this.initiator)
+            if (websocket.readyState !== WebSocket.OPEN)
+                throw new Error('传入的 websocket 连接已断开');
+            else
                 return;
-            else if (!this.url)
-                throw new Error('创建 Remote 时传入的 websocket 连接已断开');
-            else {
-                let reconnected = false;
-                // 假设有多个请求想要并发连接 websocket, 且此时 websocket 是断开的状态
-                // 应该排队依次连接，而不是后续的连接直接使用第一次连接的 promise，后续调用还是应该尝试重连（不止连接一次）
-                await this.lwebsocket.request(async (websocket) => {
-                    // 保存的 rpc 状态在 this.handlers, 与 websocket 无关，因此即使断开重连也不影响 rpc 的运行，即
-                    // 底层连接断开后自动重连对上层应该是无感知的，除非再次连接时失败
-                    if (websocket?.readyState === WebSocket.OPEN)
-                        return;
-                    // 重连
-                    try {
-                        this.lwebsocket.resource = await connect_websocket(this.url, {
-                            on_message: this._on_message,
-                            on_error: this._on_error,
-                            print: this.print
-                        });
-                        reconnected = true;
-                    }
-                    catch (error) {
-                        this._on_error(error);
-                        throw error;
-                    }
+        if (this.lwebsocket.resource?.readyState === WebSocket.OPEN)
+            return;
+        if (!this.url)
+            throw new Error('创建 Remote 时传入的 websocket 连接已断开');
+        let reconnected = false;
+        // 假设有多个请求想要并发连接 websocket, 且此时 websocket 是断开的状态
+        // 应该排队依次连接，而不是后续的连接直接使用第一次连接的 promise，后续调用还是应该尝试重连（不止连接一次）
+        await this.lwebsocket.request(async (websocket) => {
+            // 保存的 rpc 状态在 this.handlers, 与 websocket 无关，因此即使断开重连也不影响 rpc 的运行，即
+            // 底层连接断开后自动重连对上层应该是无感知的，除非再次连接时失败
+            if (websocket?.readyState === WebSocket.OPEN)
+                return;
+            // 重连
+            try {
+                this.lwebsocket.resource = await connect_websocket(this.url, {
+                    on_message: this._on_message,
+                    on_error: this._on_error,
+                    print: this.print
                 });
-                if (this.keeper) {
-                    const { heartbeat_interval, func, args } = this.keeper;
-                    // 首次连接成功时，开始心跳保活
-                    if (!this.keeping) {
-                        this.keeping = true;
-                        (async () => {
-                            for (;;) {
-                                await delay(heartbeat_interval);
-                                if (this.disconnected)
-                                    break;
-                                if (!this.reconnecting)
-                                    try {
-                                        await timeout(1000 * 2, this.call('echo'), undefined, this.print);
-                                    }
-                                    catch (error) {
-                                        if (this.print)
-                                            console.log(error.message);
-                                        this._on_error(error);
-                                    }
-                            }
-                        })();
-                    }
-                    if (reconnected && func)
-                        await this.call(func, args);
-                }
+                reconnected = true;
+            }
+            catch (error) {
+                this._on_error(error);
+                throw error;
             }
-        else if (websocket.readyState !== WebSocket.OPEN)
-            throw new Error('传入的 websocket 连接已断开');
+        });
+        if (!this.keeper)
+            return;
+        const { heartbeat_interval, func, args } = this.keeper;
+        // 首次连接成功时，开始心跳保活
+        if (!this.keeping) {
+            this.keeping = true;
+            (async () => {
+                for (;;) {
+                    await delay(heartbeat_interval);
+                    if (this.disconnected)
+                        break;
+                    if (!this.reconnecting)
+                        try {
+                            await timeout(1000 * 2, this.call('echo'), undefined, this.print);
+                        }
+                        catch (error) {
+                            if (this.print)
+                                console.log(error.message);
+                            this._on_error(error);
+                        }
+                }
+            })();
+        }
+        if (reconnected && func)
+            await this.call(func, args);
     }
     /** 作为 websocket 连接发起方手动关闭到对端的 websocket 连接 */
     disconnect() {

package/net.d.ts

@@ -1,7 +1,7 @@
 import { type Readable } from 'stream';
 import type { WebSocket, CloseEvent, ErrorEvent } from 'ws';
 import type { Cookie, CookieJar, MemoryCookieStore } from 'tough-cookie';
-import { type Message } from './io.ts';
+import { type Message } from './io.common.ts';
 import type { Encoding } from './file.ts';
 import { inspect, Lock } from './utils.ts';
 import { type BasicAuth, type BearerAuth, type RemoteKeeperOptions } from './net.common.ts';

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 { rethrow } from "./prototype.js";
-import { message_symbol, pack, parse } from "./io.js";
+import { message_symbol, pack, parse } from "./io.common.js";
 import { inspect, assert, genid, delay, Lock, pipe_with_error, map_values, unique, timeout, check, colored } from "./utils.js";
 import { drop_request_headers } from "./net.common.js";
 export * from "./net.common.js";
@@ -100,7 +100,7 @@ export async function request(url, options = {}) {
     let headers = {
         'accept-language': 'zh-CN,zh;q=0.9,en-US;q=0.8,en;q=0.7,ja-JP;q=0.6,ja;q=0.5',
         'accept-encoding': 'gzip, deflate, br',
-        'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36',
+        'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/139.0.0.0 Safari/537.36',
         'sec-ch-ua-platform': '"Windows"',
         'sec-ch-ua-platform-version': '"19.0.0"',
     };
@@ -544,62 +544,62 @@ export class Remote {
         作为 websocket 连接发起方，不需要传入 websocket
         作为 websocket 连接接收方，需要传入使用的 websocket 连接，确保这个这个连接的状态 */
     async connect(websocket) {
-        if (this.initiator)
-            if (this.lwebsocket.resource?.readyState === WebSocketOpen)
+        if (!this.initiator)
+            if (websocket.readyState !== WebSocketOpen)
+                throw new Error('传入的 websocket 连接已断开');
+            else
                 return;
-            else if (!this.url)
-                throw new Error('创建 Remote 时传入的 websocket 连接已断开');
-            else {
-                let reconnected = false;
-                // 假设有多个请求想要并发连接 websocket, 且此时 websocket 是断开的状态
-                // 应该排队依次连接，而不是后续的连接直接使用第一次连接的 promise，后续调用还是应该尝试重连（不止连接一次）
-                await this.lwebsocket.request(async (websocket) => {
-                    // 保存的 rpc 状态在 this.handlers, 与 websocket 无关，因此即使断开重连也不影响 rpc 的运行，即
-                    // 底层连接断开后自动重连对上层应该是无感知的，除非再次连接时失败
-                    if (websocket?.readyState === WebSocketOpen)
-                        return;
-                    // 重连
-                    try {
-                        this.lwebsocket.resource = await connect_websocket(this.url, {
-                            on_message: this._on_message,
-                            on_error: this._on_error,
-                            print: this.print
-                        });
-                        reconnected = true;
-                    }
-                    catch (error) {
-                        this._on_error(error);
-                        throw error;
-                    }
+        if (this.lwebsocket.resource?.readyState === WebSocketOpen)
+            return;
+        if (!this.url)
+            throw new Error('创建 Remote 时传入的 websocket 连接已断开');
+        let reconnected = false;
+        // 假设有多个请求想要并发连接 websocket, 且此时 websocket 是断开的状态
+        // 应该排队依次连接，而不是后续的连接直接使用第一次连接的 promise，后续调用还是应该尝试重连（不止连接一次）
+        await this.lwebsocket.request(async (websocket) => {
+            // 保存的 rpc 状态在 this.handlers, 与 websocket 无关，因此即使断开重连也不影响 rpc 的运行，即
+            // 底层连接断开后自动重连对上层应该是无感知的，除非再次连接时失败
+            if (websocket?.readyState === WebSocketOpen)
+                return;
+            // 重连
+            try {
+                this.lwebsocket.resource = await connect_websocket(this.url, {
+                    on_message: this._on_message,
+                    on_error: this._on_error,
+                    print: this.print
                 });
-                if (this.keeper) {
-                    const { heartbeat_interval, func, args } = this.keeper;
-                    // 首次连接成功时，开始心跳保活
-                    if (!this.keeping) {
-                        this.keeping = true;
-                        (async () => {
-                            for (;;) {
-                                await delay(heartbeat_interval);
-                                if (this.disconnected)
-                                    break;
-                                if (!this.reconnecting)
-                                    try {
-                                        await timeout(1000 * 2, this.call('echo'), undefined, this.print);
-                                    }
-                                    catch (error) {
-                                        if (this.print)
-                                            console.log(error.message);
-                                        this._on_error(error);
-                                    }
-                            }
-                        })();
-                    }
-                    if (reconnected && func)
-                        await this.call(func, args);
-                }
+                reconnected = true;
+            }
+            catch (error) {
+                this._on_error(error);
+                throw error;
             }
-        else if (websocket.readyState !== WebSocketOpen)
-            throw new Error('传入的 websocket 连接已断开');
+        });
+        if (!this.keeper)
+            return;
+        const { heartbeat_interval, func, args } = this.keeper;
+        // 首次连接成功时，开始心跳保活
+        if (!this.keeping) {
+            this.keeping = true;
+            (async () => {
+                for (;;) {
+                    await delay(heartbeat_interval);
+                    if (this.disconnected)
+                        break;
+                    if (!this.reconnecting)
+                        try {
+                            await timeout(1000 * 2, this.call('echo'), undefined, this.print);
+                        }
+                        catch (error) {
+                            if (this.print)
+                                console.log(error.message);
+                            this._on_error(error);
+                        }
+                }
+            })();
+        }
+        if (reconnected && func)
+            await this.call(func, args);
     }
     /** 作为 websocket 连接发起方手动关闭到对端的 websocket 连接 */
     disconnect() {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "xshell",
-    "version": "1.2.71",
+    "version": "1.2.73",
     "type": "module",
     "main": "./index.js",
     "bin": {
@@ -53,23 +53,23 @@
         "@babel/parser": "^7.28.0",
         "@babel/traverse": "^7.28.0",
         "@koa/cors": "^5.0.0",
-        "@stylistic/eslint-plugin": "^5.2.2",
+        "@stylistic/eslint-plugin": "^5.2.3",
         "@svgr/webpack": "^8.1.0",
         "@types/sass-loader": "^8.0.9",
         "@types/ws": "^8.18.1",
-        "@typescript-eslint/eslint-plugin": "^8.38.0",
-        "@typescript-eslint/parser": "^8.38.0",
-        "@typescript-eslint/utils": "^8.38.0",
+        "@typescript-eslint/eslint-plugin": "^8.39.0",
+        "@typescript-eslint/parser": "^8.39.0",
+        "@typescript-eslint/utils": "^8.39.0",
         "archiver": "^7.0.1",
-        "chalk": "^5.4.1",
+        "chalk": "^5.5.0",
         "commander": "^14.0.0",
         "css-loader": "^7.1.2",
         "emoji-regex": "^10.4.0",
-        "eslint": "^9.32.0",
+        "eslint": "^9.33.0",
         "eslint-plugin-import": "^2.32.0",
         "eslint-plugin-react": "^7.37.5",
         "https-proxy-agent": "^7.0.6",
-        "i18next": "^25.3.2",
+        "i18next": "^25.3.4",
         "i18next-scanner": "^4.6.0",
         "koa": "^3.0.1",
         "koa-compress": "^5.1.1",
@@ -80,7 +80,7 @@
         "react": "^19.1.1",
         "react-i18next": "^15.6.1",
         "resolve-path": "^1.4.0",
-        "sass": "^1.89.2",
+        "sass": "^1.90.0",
         "sass-loader": "^16.0.5",
         "source-map-loader": "^5.0.0",
         "strip-ansi": "^7.1.0",
@@ -104,7 +104,7 @@
         "@types/koa": "^3.0.0",
         "@types/koa-compress": "^4.0.6",
         "@types/mime-types": "^3.0.1",
-        "@types/node": "^24.0.12",
+        "@types/node": "^24.2.1",
         "@types/react": "^19.1.9",
         "@types/tough-cookie": "^4.0.5",
         "@types/ua-parser-js": "^0.7.39",

package/platform.browser.d.ts

@@ -0,0 +1 @@
+export * from './platform.common.ts';

package/platform.browser.js

@@ -0,0 +1,31 @@
+import { ident } from "./prototype.browser.js";
+import { set_platform } from "./platform.common.js";
+import { encoder } from "./utils.browser.js";
+export * from "./platform.common.js";
+function get_buffer(length) {
+    return new Uint8Array(length);
+}
+function encode(str) {
+    return encoder.encode(str);
+}
+async function delay(milliseconds, { signal } = {}) {
+    signal?.throwIfAborted();
+    return new Promise((resolve, reject) => {
+        function on_signal_abort() {
+            clearTimeout(timeout);
+            reject(signal.reason);
+        }
+        signal?.addEventListener('abort', on_signal_abort);
+        let timeout = setTimeout(() => {
+            signal?.removeEventListener('abort', on_signal_abort);
+            resolve();
+        }, milliseconds);
+    });
+}
+set_platform({
+    get_buffer,
+    encode,
+    delay,
+    strip_ansi: ident
+});
+//# sourceMappingURL=platform.browser.js.map

package/platform.common.d.ts

@@ -0,0 +1,10 @@
+import type { TimerOptions } from 'timers';
+export declare let platform: Platform;
+export declare function set_platform(_platform: Platform): void;
+interface Platform {
+    get_buffer(length: number): Uint8Array;
+    encode(str: string): Uint8Array;
+    delay(milliseconds: number, options?: TimerOptions): Promise<void>;
+    strip_ansi(str: string): string;
+}
+export {};

package/platform.common.js

@@ -0,0 +1,5 @@
+export let platform;
+export function set_platform(_platform) {
+    platform = _platform;
+}
+//# sourceMappingURL=platform.common.js.map

package/platform.d.ts

@@ -0,0 +1,2 @@
+import './prototype.ts';
+export * from './platform.common.ts';

package/platform.js

@@ -0,0 +1,22 @@
+import timers from 'timers/promises';
+import strip_ansi from 'strip-ansi';
+import "./prototype.js";
+import { set_platform } from "./platform.common.js";
+export * from "./platform.common.js";
+function get_buffer(length) {
+    return Buffer.allocUnsafe(length);
+}
+function encode(str) {
+    // 用 Buffer.from 是因为可以利用 buffer pool，避免 encoder.encode 创建大量小且独立的 array buffer
+    return Buffer.from(str);
+}
+async function delay(milliseconds, options) {
+    return timers.setTimeout(milliseconds, undefined, options);
+}
+set_platform({
+    get_buffer,
+    encode,
+    delay,
+    strip_ansi
+});
+//# sourceMappingURL=platform.js.map

package/prototype.browser.d.ts

@@ -1 +1,2 @@
+import './platform.browser.ts';
 export * from './prototype.common.ts';