xshell 1.3.6 → 1.3.8

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.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;
@@ -308,7 +308,7 @@ export function connect(hostname, port, { local_port, timeout: _timeout = 2000,
     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,

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "xshell",
-    "version": "1.3.6",
+    "version": "1.3.8",
     "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

@@ -6,6 +6,8 @@ export declare function assert<T>(assertion: T, message?: string): T;
 export declare function check<T>(condition: T, message?: string): T;
 /** 生成随机 id (number) */
 export declare function genid(): number;
+/** 生成随机 uint32 */
+export declare function genu32(): number;
 /** 通过 console.log 打印对象并返回
     @example
     log('label', obj)

package/utils.common.js

@@ -23,6 +23,10 @@ export function check(condition, message) {
 export function genid() {
     return Math.random() * 2 ** 53;
 }
+/** 生成随机 uint32 */
+export function genu32() {
+    return Math.random() * 2 ** 32 >>> 0;
+}
 export function log(...args) {
     if (args.length === 2) {
         const [label, obj] = args;
@@ -215,7 +219,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();