xshell 1.2.3 → 1.2.5

package/file.d.ts

@@ -28,13 +28,11 @@ export declare function fopen(fp: string, flags?: string | number, { mode, print
     mode: fs.Mode;
 }>;
 export declare function fread(fp: string): Promise<string>;
-export declare function fread(fp: string, { dir, encoding, print }?: {
-    dir?: string;
+export declare function fread(fp: string, options?: {
     encoding: 'binary';
     print?: boolean;
 }): Promise<Buffer>;
-export declare function fread(fp: string, { dir, encoding, print }?: {
-    dir?: string;
+export declare function fread(fp: string, options?: {
     encoding?: Encoding;
     print?: boolean;
 }): Promise<string>;
@@ -49,6 +47,9 @@ export declare function fread_json<T = any>(fp: string, options?: {
     encoding?: Encoding;
     print?: boolean;
 }): Promise<T>;
+export declare function fparse<TReturn>(fp: string, options?: {
+    print?: boolean;
+}): Promise<TReturn>;
 /** 比较两个文件是否一致，遇到任何文件系统错误都返回 false */
 export declare function fequals(fp_left: string, fp_right: string, { print }?: {
     print?: boolean;
@@ -70,6 +71,9 @@ interface FWriteOptions {
         - print?: `true` */
 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>;
+export declare function fpack(fp: string, data: any, options?: FWriteOptions): Promise<string>;
+export declare function fpack(fp: FileHandle, data: any, options?: FWriteOptions): Promise<FileHandle>;
 /** 追加内容到文件末尾，如果文件不存在会自动创建 */
 export declare function fappend(fp: string, data: string | Uint8Array, { print }?: {
     print?: boolean;

package/file.js

@@ -1,8 +1,9 @@
 import { promises as fsp, default as fs } from 'fs';
 import { isUint8Array } from 'util/types';
-import { path } from "./path.js";
 import { t } from "./i18n/instance.js";
 import { to_json } from "./prototype.js";
+import { pack, parse } from "./io.js";
+import { path } from "./path.js";
 import { check, Lock, WritableMemoryStream, url_width } from "./utils.js";
 export { fsp };
 export const encodings = ['utf-8', 'gb18030', 'shift-jis', 'utf-16le'];
@@ -53,6 +54,9 @@ export async function fread_lines(fp, options = {}) {
 export async function fread_json(fp, options = {}) {
     return JSON.parse(await fread(fp, options));
 }
+export async function fparse(fp, options) {
+    return parse(await fread(fp, { ...options, encoding: 'binary' }));
+}
 /** 比较两个文件是否一致，遇到任何文件系统错误都返回 false */
 export async function fequals(fp_left, fp_right, { print = true } = {}) {
     if (print)
@@ -97,6 +101,9 @@ export async function fwrite(fp, data, { print = true } = {}) {
     }
     return fp;
 }
+export async function fpack(fp, data, options) {
+    return fwrite(fp, pack(data), options);
+}
 /** 追加内容到文件末尾，如果文件不存在会自动创建 */
 export async function fappend(fp, data, { print = true } = {}) {
     check(path.isAbsolute(fp), `${t('fp 必须是绝对路径，当前为:')} ${fp}`);
@@ -560,6 +567,6 @@ export async function freplace(fp, pattern, replacement, { print = true } = {})
         .replaceAll(pattern, replacement), { print });
 }
 function log_action(action, fp_src, fp_dst, sep = '->') {
-    console.log(`${`${action} ${fp_src}`.pad(url_width)} ${sep} ${fp_dst}`);
+    console.log(`${`${action}  ${fp_src}`.pad(url_width)}  ${sep}  ${fp_dst}`);
 }
 //# sourceMappingURL=file.js.map

package/io.browser.js

@@ -476,9 +476,12 @@ function _pack(value) {
                 }
                 nkv = 0;
                 for (const key in value) {
+                    const v = value[key];
+                    if (typeof v === 'function')
+                        continue;
                     _pack(key);
-                    _pack(value[key]);
-                    if (nkv++ > 0xffff)
+                    _pack(v);
+                    if (++nkv > 0xffff)
                         throw new Error('对象 key 数量大于 65535，无法序列化');
                 }
                 if (nkv >= 16)

package/io.js

@@ -476,9 +476,12 @@ function _pack(value) {
                 }
                 nkv = 0;
                 for (const key in value) {
+                    const v = value[key];
+                    if (typeof v === 'function')
+                        continue;
                     _pack(key);
-                    _pack(value[key]);
-                    if (nkv++ > 0xffff)
+                    _pack(v);
+                    if (++nkv > 0xffff)
                         throw new Error('对象 key 数量大于 65535，无法序列化');
                 }
                 if (nkv >= 16)

package/net.browser.d.ts

@@ -101,11 +101,8 @@ export declare function connect_websocket(url: string | URL, { protocols, on_mes
     print?: boolean;
 }): Promise<WebSocket>;
 /** 接收到消息后的处理函数
-    返回值可以是:
-    - 数组: 会自动被封装为 { id: 相同, data: 返回值, done: true } 这样的消息并调用 websocket.send 将其发送
-    - void: 什么都不做
-    - 以上的 promise */
-export type MessageHandler<TData extends any[] = any[]> = (message: Message<TData>, websocket?: WebSocket) => void | any[] | Promise<void | any[]>;
+    返回值会自动被 await，然后可能被封装为 message 回传 */
+export type MessageHandler<TData = any> = (message: Message<TData>, websocket?: WebSocket) => void | any | Promise<void | any>;
 /** 自动保持 remote 连接，只对 initiator 且传入 url 有效，
     - 在未连接，或 websocket on_error 检测到连接断开后以 reconnect_interval 间隔尝试 remote.call(func) 重连
     - 在连接状态下以 heartbeat_interval 间隔发送心跳包确保连接状态
@@ -159,7 +156,7 @@ export declare class Remote {
     funcs: Record<string, MessageHandler>;
     /** map<id, message handler>: 通过 (rpc message).id 找到对应的 handler
         一元 rpc 接收方不需要设置 handlers, 发送方需要 */
-    handlers: Map<number, MessageHandler<any[]>>;
+    handlers: Map<number, MessageHandler<any>>;
     keeper?: RemoteKeeperOptions;
     /** `true` 是否打印连接信息、错误信息 */
     print: boolean;
@@ -198,14 +195,17 @@ export declare class Remote {
         作为 websocket 连接接收方，必传 websocket 参数
         发送或连接出错时自动清理 message.id 对应的 handler */
     send(message: Message, websocket?: WebSocket): Promise<void>;
-    /** 处理接收到的 websocket message 并解析, 根据 message.id 或 message.func 分发到对应的 handler 进行处理
+    /** 处理接收到的 websocket message 并解析, 根据 message.id 或 message.func 分发到对应的 handler 进行处理，
+        handler 处理完成后:
+        - 传了 func: 调用函数的情况下 (通常是一元 rpc)，总是将返回值包装为 message 回传
+        - 未传 func: 通过 id 调用，如果 handler 返回非 undefined 的值，也包装为 message 回传
+        
         如果 message.done == true 则对端指示当前 remote 可以清理 handler
-        如果 handler 返回了值 (一定是数组)，则包装为 message 发送
         使用 Uint8Array 作为参数更灵活 https://stackoverflow.com/a/74505197/7609214
         这个方法一般不会抛出错误，也不需要 await，一般在 websocket on_message 时使用 */
     handle(data: Uint8Array, websocket: WebSocket): Promise<void>;
     /** 调用对端 remote 中的 func, 只适用于最简单的一元 rpc (请求, 响应)
         作为 websocket 连接发起方，不需要传入 websocket
         作为 websocket 连接接收方，必传 websocket 参数  */
-    call<TReturn extends any[] = any[]>(func: string, args?: any[], websocket?: WebSocket): Promise<TReturn>;
+    call<TReturn = any>(func: string, args?: any[], websocket?: WebSocket): Promise<TReturn>;
 }

package/net.browser.js

@@ -431,7 +431,6 @@ export class Remote {
         作为 websocket 连接接收方，必传 websocket 参数
         发送或连接出错时自动清理 message.id 对应的 handler */
     async send(message, websocket) {
-        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 {
@@ -445,9 +444,12 @@ export class Remote {
             throw error;
         }
     }
-    /** 处理接收到的 websocket message 并解析, 根据 message.id 或 message.func 分发到对应的 handler 进行处理
+    /** 处理接收到的 websocket message 并解析, 根据 message.id 或 message.func 分发到对应的 handler 进行处理，
+        handler 处理完成后:
+        - 传了 func: 调用函数的情况下 (通常是一元 rpc)，总是将返回值包装为 message 回传
+        - 未传 func: 通过 id 调用，如果 handler 返回非 undefined 的值，也包装为 message 回传
+        
         如果 message.done == true 则对端指示当前 remote 可以清理 handler
-        如果 handler 返回了值 (一定是数组)，则包装为 message 发送
         使用 Uint8Array 作为参数更灵活 https://stackoverflow.com/a/74505197/7609214
         这个方法一般不会抛出错误，也不需要 await，一般在 websocket on_message 时使用 */
     async handle(data, websocket) {
@@ -464,8 +466,12 @@ export class Remote {
         if (this.verbose)
             console.log('remote.handle:', message);
         let handler;
-        if (func)
+        if (func) {
             handler = this.funcs[func];
+            // 传了 func 调用函数的情况下，如果 message.data 为 undefined, 默认为 [ ]
+            if (message.data === undefined)
+                message.data = [];
+        }
         else {
             handler = this.handlers.get(id);
             if (done && handler)
@@ -474,7 +480,7 @@ export class Remote {
         try {
             if (handler) {
                 const data = await handler(message, websocket);
-                if (data)
+                if (func || data !== undefined)
                     await this.send({ id, data }, websocket);
             }
             else

package/net.d.ts

@@ -163,11 +163,8 @@ on_message, on_error, on_close, proxy, print, }: {
     print?: boolean;
 }): Promise<WebSocket>;
 /** 接收到消息后的处理函数
-    返回值可以是:
-    - 数组: 会自动被封装为 { id: 相同, data: 返回值, done: true } 这样的消息并调用 websocket.send 将其发送
-    - void: 什么都不做
-    - 以上的 promise */
-export type MessageHandler<TData extends any[] = any[]> = (message: Message<TData>, websocket?: WebSocket) => void | any[] | Promise<void | any[]>;
+    返回值会自动被 await，然后可能被封装为 message 回传 */
+export type MessageHandler<TData = any> = (message: Message<TData>, websocket?: WebSocket) => void | any | Promise<void | any>;
 /** 自动保持 remote 连接，只对 initiator 且传入 url 有效，
     - 在未连接，或 websocket on_error 检测到连接断开后以 reconnect_interval 间隔尝试 remote.call(func) 重连
     - 在连接状态下以 heartbeat_interval 间隔发送心跳包确保连接状态
@@ -221,7 +218,7 @@ export declare class Remote {
     funcs: Record<string, MessageHandler>;
     /** map<id, message handler>: 通过 (rpc message).id 找到对应的 handler
         一元 rpc 接收方不需要设置 handlers, 发送方需要 */
-    handlers: Map<number, MessageHandler<any[]>>;
+    handlers: Map<number, MessageHandler<any>>;
     keeper?: RemoteKeeperOptions;
     /** `true` 是否打印连接信息、错误信息 */
     print: boolean;
@@ -260,16 +257,19 @@ export declare class Remote {
         作为 websocket 连接接收方，必传 websocket 参数
         发送或连接出错时自动清理 message.id 对应的 handler */
     send(message: Message, websocket?: WebSocket): Promise<void>;
-    /** 处理接收到的 websocket message 并解析, 根据 message.id 或 message.func 分发到对应的 handler 进行处理
+    /** 处理接收到的 websocket message 并解析, 根据 message.id 或 message.func 分发到对应的 handler 进行处理，
+        handler 处理完成后:
+        - 传了 func: 调用函数的情况下 (通常是一元 rpc)，总是将返回值包装为 message 回传
+        - 未传 func: 通过 id 调用，如果 handler 返回非 undefined 的值，也包装为 message 回传
+        
         如果 message.done == true 则对端指示当前 remote 可以清理 handler
-        如果 handler 返回了值 (一定是数组)，则包装为 message 发送
         使用 Uint8Array 作为参数更灵活 https://stackoverflow.com/a/74505197/7609214
         这个方法一般不会抛出错误，也不需要 await，一般在 websocket on_message 时使用 */
     handle(data: Uint8Array, websocket: WebSocket): Promise<void>;
     /** 调用对端 remote 中的 func, 只适用于最简单的一元 rpc (请求, 响应)
         作为 websocket 连接发起方，不需要传入 websocket
         作为 websocket 连接接收方，必传 websocket 参数  */
-    call<TReturn extends any[] = any[]>(func: string, args?: any[], websocket?: WebSocket): Promise<TReturn>;
+    call<TReturn = any>(func: string, args?: any[], websocket?: WebSocket): Promise<TReturn>;
 }
 /** 为连接到 server 的 client 创建 RemoteClient，以便后续调用 client 中方法 */
 export declare class RemoteClient {
@@ -277,7 +277,7 @@ export declare class RemoteClient {
     websocket: WebSocket;
     constructor(remote: Remote, websocket: WebSocket);
     /** 调用 client 中的 func, 只适用于最简单的一元 rpc (请求, 响应) */
-    call<TReturn extends any[] = any[]>(func: string, args?: any[]): Promise<TReturn>;
+    call<TReturn = any>(func: string, args?: any[]): Promise<TReturn>;
     /** 发送 message 到 client
         发送或连接出错时自动清理 message.id 对应的 handler */
     send(message: Message): Promise<void>;

package/net.js

@@ -616,7 +616,6 @@ export class Remote {
         作为 websocket 连接接收方，必传 websocket 参数
         发送或连接出错时自动清理 message.id 对应的 handler */
     async send(message, websocket) {
-        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 {
@@ -630,9 +629,12 @@ export class Remote {
             throw error;
         }
     }
-    /** 处理接收到的 websocket message 并解析, 根据 message.id 或 message.func 分发到对应的 handler 进行处理
+    /** 处理接收到的 websocket message 并解析, 根据 message.id 或 message.func 分发到对应的 handler 进行处理，
+        handler 处理完成后:
+        - 传了 func: 调用函数的情况下 (通常是一元 rpc)，总是将返回值包装为 message 回传
+        - 未传 func: 通过 id 调用，如果 handler 返回非 undefined 的值，也包装为 message 回传
+        
         如果 message.done == true 则对端指示当前 remote 可以清理 handler
-        如果 handler 返回了值 (一定是数组)，则包装为 message 发送
         使用 Uint8Array 作为参数更灵活 https://stackoverflow.com/a/74505197/7609214
         这个方法一般不会抛出错误，也不需要 await，一般在 websocket on_message 时使用 */
     async handle(data, websocket) {
@@ -649,8 +651,12 @@ export class Remote {
         if (this.verbose)
             console.log('remote.handle:', message);
         let handler;
-        if (func)
+        if (func) {
             handler = this.funcs[func];
+            // 传了 func 调用函数的情况下，如果 message.data 为 undefined, 默认为 [ ]
+            if (message.data === undefined)
+                message.data = [];
+        }
         else {
             handler = this.handlers.get(id);
             if (done && handler)
@@ -659,7 +665,7 @@ export class Remote {
         try {
             if (handler) {
                 const data = await handler(message, websocket);
-                if (data)
+                if (func || data !== undefined)
                     await this.send({ id, data }, websocket);
             }
             else

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "xshell",
-    "version": "1.2.3",
+    "version": "1.2.5",
     "type": "module",
     "main": "./index.js",
     "bin": {
@@ -60,16 +60,10 @@
         "@typescript-eslint/eslint-plugin": "^8.20.0",
         "@typescript-eslint/parser": "^8.20.0",
         "@typescript-eslint/utils": "^8.20.0",
-        "@xterm/addon-fit": "^0.10.0",
-        "@xterm/addon-web-links": "^0.11.0",
-        "@xterm/addon-webgl": "^0.18.0",
-        "@xterm/xterm": "^5.5.0",
         "archiver": "^7.0.1",
         "chalk": "^5.4.1",
-        "chardet": "^2.0.0",
         "cli-table3": "^0.6.5",
         "cli-truncate": "^4.0.0",
-        "colors": "^1.4.0",
         "commander": "^13.0.0",
         "css-loader": "^7.1.2",
         "emoji-regex": "^10.4.0",
@@ -77,7 +71,6 @@
         "eslint-plugin-import": "^2.31.0",
         "eslint-plugin-react": "^7.37.4",
         "gulp-sort": "^2.0.0",
-        "hash-string": "^1.0.0",
         "https-proxy-agent": "^7.0.6",
         "i18next": "^24.2.1",
         "i18next-scanner": "^4.6.0",
@@ -103,7 +96,7 @@
         "tslib": "^2.8.1",
         "typescript": "^5.7.3",
         "ua-parser-js": "^2.0.0",
-        "undici": "^7.2.1",
+        "undici": "^7.2.2",
         "vinyl": "^3.0.0",
         "vinyl-fs": "^4.0.0",
         "webpack": "^5.97.1",
@@ -114,7 +107,6 @@
         "@babel/types": "^7.26.5",
         "@types/archiver": "^6.0.3",
         "@types/babel__traverse": "^7.20.6",
-        "@types/chardet": "^1.0.0",
         "@types/eslint": "^9.6.1",
         "@types/estree": "^1.0.6",
         "@types/gulp-sort": "^2.0.4",
@@ -122,7 +114,7 @@
         "@types/koa-compress": "^4.0.6",
         "@types/lodash": "^4.17.14",
         "@types/mime-types": "^2.1.4",
-        "@types/node": "^22.10.6",
+        "@types/node": "^22.10.7",
         "@types/react": "^19.0.7",
         "@types/through2": "^2.0.41",
         "@types/tough-cookie": "^4.0.5",

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;