xshell 1.1.15 → 1.1.17

package/{stdin.d.ts → development.d.ts}

@@ -2,3 +2,5 @@
     - on_key: 按键处理函数
     - on_exit?: ctrl + c 会退出进程，可加入退出前自定义处理逻辑 */
 export declare function process_stdin(on_key: (key: string) => void | Promise<void>, on_exit?: () => void | Promise<void>): void;
+/** 自动配置项目 vscode 设置 */
+export declare function setup_vscode_settings(fpd_root: string): Promise<void>;

package/{stdin.js → development.js}

@@ -1,4 +1,6 @@
 import process from 'process';
+import { fcopy, fexists, ramdisk } from "./file.js";
+import { noprint } from "./process.js";
 /** 监听终端按键 (输入)，并调用 key_processor 处理
     - on_key: 按键处理函数
     - on_exit?: ctrl + c 会退出进程，可加入退出前自定义处理逻辑 */
@@ -22,4 +24,12 @@ export function process_stdin(on_key, on_exit) {
         await on_key(key);
     });
 }
-//# sourceMappingURL=stdin.js.map
+/** 自动配置项目 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);
+    }
+}
+//# sourceMappingURL=development.js.map

package/net.browser.js

@@ -384,7 +384,7 @@ export class Remote {
                 this.reconnecting = false;
                 if (!this.disconnected)
                     try {
-                        await timeout(3000, async () => { await this.connect(); }, undefined, this.print);
+                        await timeout(3000, this.connect(), undefined, this.print);
                         this.first_error = true;
                     }
                     catch (error) {
@@ -451,7 +451,7 @@ export class Remote {
                                     break;
                                 if (!this.reconnecting)
                                     try {
-                                        await timeout(1000 * 2, async () => { await this.call('echo', []); }, undefined, this.print);
+                                        await timeout(1000 * 2, this.call('echo'), undefined, this.print);
                                     }
                                     catch (error) {
                                         if (this.print)

package/net.js

@@ -46,7 +46,7 @@ async function request_retry(url, options, _timeout, retries = 0, count = 0, pri
             // 设置给 undici 设置 timeout, signal 不一定管用，还是得自己兜底
             options.signal = AbortSignal.timeout(_timeout);
             return await timeout(_timeout + 300, // 为 undici 兜底
-            async () => undici.request(url, options), undefined, print.timeout && count >= retries // 只打印最后一次超时的错误，避免太多冗余输出
+            undici.request(url, options), undefined, print.timeout && count >= retries // 只打印最后一次超时的错误，避免太多冗余输出
             );
         }
         else
@@ -569,7 +569,7 @@ export class Remote {
                 this.reconnecting = false;
                 if (!this.disconnected)
                     try {
-                        await timeout(3000, async () => { await this.connect(); }, undefined, this.print);
+                        await timeout(3000, this.connect(), undefined, this.print);
                         this.first_error = true;
                     }
                     catch (error) {
@@ -636,7 +636,7 @@ export class Remote {
                                     break;
                                 if (!this.reconnecting)
                                     try {
-                                        await timeout(1000 * 2, async () => { await this.call('echo', []); }, undefined, this.print);
+                                        await timeout(1000 * 2, this.call('echo'), undefined, this.print);
                                     }
                                     catch (error) {
                                         if (this.print)

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "xshell",
-    "version": "1.1.15",
+    "version": "1.1.17",
     "type": "module",
     "main": "./index.js",
     "bin": {

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;

package/process.d.ts

@@ -49,6 +49,8 @@ interface BaseOptions {
         
         具体有什么用还不清楚 */
     window?: boolean;
+    /** 由创建进程的调用者设置的，用于区分、识别、记忆的可选名称 */
+    title?: string;
 }
 export interface StartOptions extends BaseOptions {
     /** `true` 是否打印启动命令行 */
@@ -60,7 +62,25 @@ export interface StartOptions extends BaseOptions {
     /** 使用文件作为标准错误 */
     fp_stderr?: string;
 }
-/** 启动独立的进程，不受当前 node.js 进程退出的影响
+export declare function get_command(exe: string, args?: string[]): string;
+export interface SubProcess<TOutput extends string | Buffer = string> extends ChildProcess {
+    /** 由创建进程的调用者设置的，用于区分、识别、记忆的可选名称 */
+    title?: string;
+    /** 启动的 exe 路径，等于传入 call, start 的 exe */
+    exe: string;
+    /** 启动参数, 无参数时确保为 `[ ]` */
+    args: string[];
+    /** 启动命令 */
+    command: string;
+    /** 调用 call 的 Promise 结果，call, launch 都有，start 创建的进程没有 */
+    presult: Promise<CallResult<TOutput>>;
+    /** 是否还在运行 */
+    get running(): boolean;
+    /** 是否已结束，等价于 !running */
+    get finished(): boolean;
+}
+/** 启动独立 (detached) 的进程，不受当前 node.js 进程退出的影响，重定向 stdio 到文件或直接忽略
+    使用 windowsHide 选项避免创建命令行窗口
     - exe: .exe 路径或文件名 (建议使用完整路径，跳过 path 搜索，性能更高)
     - args?: `[ ]` 参数列表
     - options?:
@@ -72,7 +92,7 @@ export interface StartOptions extends BaseOptions {
         - fp_stdin?: 使用文件作为标准输入，设置 stdio 中对应的值
         - fp_stdout?: 使用文件作为标准输出，设置 stdio 中对应的值
         - fp_stderr?: 使用文件作为标准错误，设置 stdio 中对应的值 */
-export declare function start(exe: string, args?: string[], options?: StartOptions): Promise<ChildProcess>;
+export declare function start(exe: string, args?: string[], options?: StartOptions): Promise<SubProcess>;
 export interface CallOptions extends BaseOptions {
     /** `true` print 选项，支持设置细项 */
     print?: boolean | FullPrintOptions;
@@ -80,8 +100,11 @@ export interface CallOptions extends BaseOptions {
     throw_code?: boolean;
     /** `'utf-8'` 子进程输出编码 */
     encoding?: 'binary' | Encoding;
-    /** `'pipe'` 设置为 'ignore' 时忽略 stdio 处理 */
+    /** `[stdin ? 'pipe' : 'ignore', 'pipe', 'pipe']` 设置为 'ignore' 时忽略 stdio 处理 */
     stdio?: 'pipe' | 'ignore' | [StdioType, StdioType, StdioType];
+    /** `false` 子进程是否可能会读取 stdin
+        设置为 true 时会设置子进程 stdin 为 'pipe', 否则为 'ignore' */
+    stdin?: boolean;
     /** 启动子进程之后写入到子进程 stdin 中的内容，写完后关闭子进程 stdin */
     input?: string;
     /** 实时处理 stdout 和 stderr 的每个 chunk，启用后子进程输出不会自动 print */
@@ -90,7 +113,7 @@ export interface CallOptions extends BaseOptions {
         stderr?: (chunk: string) => void;
     };
     /** 可以传入回调函数及时获取通过 start 创建的子进程，便于执行 kill、获得 pid 等操作 */
-    on_child?: (child: ChildProcess) => void;
+    on_child?: (child: SubProcess) => void;
 }
 export interface CallResult<TOutput extends string | Buffer = string> {
     pid: number;
@@ -100,7 +123,7 @@ export interface CallResult<TOutput extends string | Buffer = string> {
     signal: NodeJS.Signals | null;
     command: string;
     message: string;
-    child: ChildProcess;
+    child: SubProcess<TOutput>;
     print: FullPrintOptions;
 }
 export interface CallError<TOutput extends string | Buffer = string> extends Error {
@@ -110,7 +133,7 @@ export interface CallError<TOutput extends string | Buffer = string> extends Err
     code: number;
     signal: NodeJS.Signals;
     command: string;
-    child: ChildProcess;
+    child: SubProcess<TOutput>;
     print: FullPrintOptions;
 }
 export declare class CallError<TOutput extends string | Buffer = string> extends Error {
@@ -118,7 +141,7 @@ export declare class CallError<TOutput extends string | Buffer = string> extends
     constructor({ message, pid, stdout, stderr, code, signal, command, child, print }: CallResult<TOutput>);
     [inspect.custom](depth: number, options: InspectOptions, inspect: Function): string;
 }
-/** 调用可执行文件，获取返回结果，错误时抛出 CallError
+/** 调用 exe 启动子进程，等待并获取返回结果，错误时抛出 CallError
     - exe: .exe 路径或文件名 (建议使用路径，跳过 path 搜索，性能更高)
     - args: `[ ]` 参数列表
     - options?:
@@ -135,14 +158,26 @@ export declare function call(exe: string, args: string[], options: CallOptions &
     encoding: 'binary';
 }): Promise<CallResult<Buffer>>;
 export declare function call(exe: string, args?: string[], options?: CallOptions): Promise<CallResult<string>>;
-export interface CallNodeJsOptions extends CallOptions {
+/** 调用 exe 启动子进程（通常是长期在后台运行的，或者可交互的，需要能控制）
+    返回 {@link SubProcess} 对象 (继承自 ChildProcess)，可以做 .kill() 等操作
+    其中有 presult 属性，是调用 call 的 Promise 结果
+    - exe: .exe 路径或文件名 (建议使用路径，跳过 path 搜索，性能更高)
+    - args: `[ ]` 参数列表
+    - options?: 见 {@link CallOptions} */
+export declare function launch(exe: string, args: string[], options: CallOptions & {
+    encoding: 'binary';
+}): Promise<SubProcess<Buffer>>;
+export declare function launch(exe: string, args?: string[], options?: CallOptions): Promise<SubProcess<string>>;
+export interface NodeJsOptions {
     inspect?: number | true;
     break?: boolean;
 }
+export interface CallNodeJsOptions extends CallOptions, NodeJsOptions {
+}
 /** 调用 node <js> 并等待结果
     - js: .js 路径 (相对路径根据 cwd 解析)
     - args?: `[ ]` 参数列表
-    - options?:
+    - options?: {@link CallNodeJsOptions} 继承自 {@link CallOptions} 和 {@link NodeJsOptions}
         - cwd?: `'T:/'`
         - envs?: `process.env` 覆盖／添加到 process.env 的环境变量
         - encoding?: `'utf-8'` 子进程输出编码
@@ -151,19 +186,29 @@ export interface CallNodeJsOptions extends CallOptions {
         - throw_code?: `true` code 不为 0 时是否抛出异常
         - inspect?: nodejs debugger port, 填 9229 端口 (或者传 true) 可以用临时配置来调试
         - break?: break at first line */
-export declare function call_nodejs(js: string, args?: string[], { inspect, break: _break, ...options }?: CallNodeJsOptions): Promise<CallResult<string>>;
-export interface StartNodeJsOptions extends StartOptions {
-    inspect?: number | true;
-    break?: boolean;
+export declare function call_nodejs(js: string, args?: string[], options?: CallNodeJsOptions): Promise<CallResult<string>>;
+export interface StartNodeJsOptions extends StartOptions, NodeJsOptions {
 }
-/** 启动 node <js>
+/** 启动独立的 node.js 进程 (detached)，执行某个 js 文件
     - js: .js 路径 (相对路径根据 cwd 解析)
     - args: `[]` 参数列表
-    - options
-        - cwd?: `'T:/'`
-        - envs?: `process.env` 覆盖／添加到 process.env 的环境变量
-        - print?: `true` print 选项，支持设置细项
+    - options?: {@link StartNodeJsOptions} 继承自 {@link StartOptions} 和 {@link NodeJsOptions}
         - inspect?: nodejs debugger port, 填 9229 端口 (或者传 true) 可以用临时配置来调试
-        - break?: break at first line */
-export declare function start_nodejs(js: string, args?: string[], { inspect, break: _break, ...options }?: StartNodeJsOptions): Promise<ChildProcess>;
+        - break?: 在第一行停止 */
+export declare function start_nodejs(js: string, args?: string[], options?: StartNodeJsOptions): Promise<SubProcess<string>>;
+/** 启动子 node.js 进程（通常是长期在后台运行的，或者可交互的，需要能控制），执行某个 js 文件，
+    返回 {@link SubProcess} 对象 (继承自 ChildProcess)，可以做 .kill() 等操作
+    - js: .js 路径 (相对路径根据 cwd 解析)
+    - args: `[]` 参数列表
+    - options?: {@link CallNodeJsOptions} 继承自 {@link CallOptions} 和 {@link NodeJsOptions}
+        - inspect?: nodejs debugger port, 填 9229 端口 (或者传 true) 可以用临时配置来调试
+        - break?: 在第一行停止 */
+export declare function launch_nodejs(js: string, args?: string[], options?: CallNodeJsOptions): Promise<SubProcess<string>>;
+/** 可选的向子进程输入内容，并等待子进程输出特定的内容，类似一次无返回值，仅有完成状态的 rpc 调用
+    根据文本内容匹配其实不太好，实在是没有别的 rpc 方法再使用吧
+    - ps: 子进程
+    - pattern: 匹配内容，支持 string 和 RegExp
+    - input?: 要输入的内容
+    - timeout?: 等待超时时间 */
+export declare function wait_output(ps: SubProcess, pattern: string | RegExp, input?: string, _timeout?: number): Promise<void>;
 export {};

package/process.js

@@ -2,16 +2,24 @@ import { spawn } from 'child_process';
 import os from 'os';
 import node_sea from 'node:sea';
 import "./prototype.js";
-import { inspect, DecoderStream, filter_values, check, colored } from "./utils.js";
+import { inspect, DecoderStream, filter_values, check, colored, timeout } from "./utils.js";
 export const sea = node_sea.isSea();
 export const exe_nodejs = process.execPath.fp;
 export const platform = os.platform();
 export const username = os.userInfo().username;
 export const noprint = { print: false };
 export const print_no_command = { print: { command: false, code: false, stdout: true, stderr: true } };
+export function get_command(exe, args) {
+    return (short_exe_names[exe] || exe.quote_if_space()) +
+        (args?.length
+            ? ` ${args.map(arg => arg.quote_if_space()).join(' ')}`
+            : '');
+}
 async function prepare_spawn(detached, exe, args, { cwd, window: _window, envs, 
 // @ts-ignore
-input, fp_stdin, fp_stdout, fp_stderr, print = true, proxy, 
+input, 
+// @ts-ignore
+stdin, fp_stdin, fp_stdout, fp_stderr, print = true, proxy, 
 // @ts-ignore
 stdio }) {
     // --- 处理 proxy, envs
@@ -46,7 +54,12 @@ stdio }) {
     else if (detached)
         stdio = ['ignore', 'ignore', 'ignore'];
     else
-        stdio = [input ? 'pipe' : 'ignore', 'pipe', 'pipe'];
+        stdio = [
+            // 当子进程 stdin 为 'ignore' 时，python 会报错 [WinError 6] 句柄无效，cmd / powershell 都会立即结束退出
+            (stdin || input) ? 'pipe' : 'ignore',
+            'pipe',
+            'pipe'
+        ];
     if (fp_stdin || fp_stdout || fp_stderr) {
         const { fopen } = await import("./file.js");
         async function open(fp, flags) {
@@ -71,6 +84,7 @@ stdio }) {
     }
     if (detached)
         check(stdio.every((x) => x === 'ignore' || typeof x === 'number'), '调用 start 时 stdio 只能是 fd 或者 ignore');
+    // --- 处理 stdio 结束
     if (typeof print === 'boolean')
         print = {
             command: print,
@@ -78,13 +92,7 @@ stdio }) {
             stdout: print,
             stderr: print
         };
-    const command = (short_exe_names[exe] || exe.quote_if_space()) +
-        (args.length
-            ? ' ' +
-                args
-                    .map(arg => arg.quote_if_space())
-                    .join(' ')
-            : '');
+    const command = get_command(exe, args);
     if (print.command)
         console.log(command.blue);
     return {
@@ -102,7 +110,40 @@ stdio }) {
         close_all_handles: opened_handles.length ? close_all_handles : undefined
     };
 }
-/** 启动独立的进程，不受当前 node.js 进程退出的影响
+function to_subprocess(child, { title, exe, args, command, }) {
+    if (title)
+        child.title = title;
+    child.exe = exe;
+    child.args = args || [];
+    child.command = command;
+    child[inspect.custom] = () => {
+        const { title, command, running, exitCode, presult } = child;
+        return {
+            ...title ? { title } : {},
+            command,
+            running,
+            ...running ? {} : {
+                code: exitCode,
+                presult
+            }
+        };
+    };
+    Object.defineProperties(child, {
+        finished: {
+            get() {
+                return this.exitCode !== null;
+            }
+        },
+        running: {
+            get() {
+                return this.exitCode === null;
+            }
+        }
+    });
+    return child;
+}
+/** 启动独立 (detached) 的进程，不受当前 node.js 进程退出的影响，重定向 stdio 到文件或直接忽略
+    使用 windowsHide 选项避免创建命令行窗口
     - exe: .exe 路径或文件名 (建议使用完整路径，跳过 path 搜索，性能更高)
     - args?: `[ ]` 参数列表
     - options?:
@@ -115,9 +156,9 @@ stdio }) {
         - fp_stdout?: 使用文件作为标准输出，设置 stdio 中对应的值
         - fp_stderr?: 使用文件作为标准错误，设置 stdio 中对应的值 */
 export async function start(exe, args = [], options = {}) {
-    const { spawn_options, close_all_handles } = await prepare_spawn(true, exe, args, options);
+    const { spawn_options, close_all_handles, command } = await prepare_spawn(true, exe, args, options);
     try {
-        let child = spawn(exe, args, spawn_options);
+        let child = to_subprocess(spawn(exe, args, spawn_options), { exe, command, args, title: options.title });
         child.unref();
         return child;
     }
@@ -157,7 +198,7 @@ export async function call(exe, args = [], options = {}) {
     const { print, spawn_options, close_all_handles, command } = await prepare_spawn(false, exe, args, options);
     let child;
     try {
-        child = spawn(exe, args, spawn_options);
+        child = to_subprocess(spawn(exe, args, spawn_options), { exe, args, command, title: options.title });
     }
     finally {
         if (close_all_handles)
@@ -253,14 +294,30 @@ export async function call(exe, args = [], options = {}) {
             });
         }
     };
-    if (throw_code && (code || signal))
+    if (throw_code && code)
         throw new CallError(result);
     return result;
 }
+export async function launch(exe, args, options) {
+    let presult;
+    let ps = await new Promise((resolve, reject) => {
+        try {
+            presult = call(exe, args, {
+                on_child: resolve,
+                ...options,
+            });
+        }
+        catch (error) {
+            reject(error);
+        }
+    });
+    ps.presult = presult;
+    return ps;
+}
 /** 调用 node <js> 并等待结果
     - js: .js 路径 (相对路径根据 cwd 解析)
     - args?: `[ ]` 参数列表
-    - options?:
+    - options?: {@link CallNodeJsOptions} 继承自 {@link CallOptions} 和 {@link NodeJsOptions}
         - cwd?: `'T:/'`
         - envs?: `process.env` 覆盖／添加到 process.env 的环境变量
         - encoding?: `'utf-8'` 子进程输出编码
@@ -269,30 +326,69 @@ export async function call(exe, args = [], options = {}) {
         - throw_code?: `true` code 不为 0 时是否抛出异常
         - inspect?: nodejs debugger port, 填 9229 端口 (或者传 true) 可以用临时配置来调试
         - break?: break at first line */
-export async function call_nodejs(js, args = [], { inspect, break: _break, ...options } = {}) {
-    return call(exe_nodejs, [
-        '--enable-source-maps',
-        ...inspect ? [`--inspect${_break ? '-brk' : ''}=localhost:${inspect === true ? 9229 : inspect}`] : [],
-        js,
-        ...args
-    ], options);
+export async function call_nodejs(js, args, options) {
+    return call(exe_nodejs, get_nodejs_args(js, args, options), options);
 }
-/** 启动 node <js>
+/** 启动独立的 node.js 进程 (detached)，执行某个 js 文件
     - js: .js 路径 (相对路径根据 cwd 解析)
     - args: `[]` 参数列表
-    - options
-        - cwd?: `'T:/'`
-        - envs?: `process.env` 覆盖／添加到 process.env 的环境变量
-        - print?: `true` print 选项，支持设置细项
+    - options?: {@link StartNodeJsOptions} 继承自 {@link StartOptions} 和 {@link NodeJsOptions}
         - inspect?: nodejs debugger port, 填 9229 端口 (或者传 true) 可以用临时配置来调试
-        - break?: break at first line */
-export async function start_nodejs(js, args = [], { inspect, break: _break, ...options } = {}) {
-    return start(exe_nodejs, [
+        - break?: 在第一行停止 */
+export async function start_nodejs(js, args, options) {
+    return start(exe_nodejs, get_nodejs_args(js, args, options), options);
+}
+/** 启动子 node.js 进程（通常是长期在后台运行的，或者可交互的，需要能控制），执行某个 js 文件，
+    返回 {@link SubProcess} 对象 (继承自 ChildProcess)，可以做 .kill() 等操作
+    - js: .js 路径 (相对路径根据 cwd 解析)
+    - args: `[]` 参数列表
+    - options?: {@link CallNodeJsOptions} 继承自 {@link CallOptions} 和 {@link NodeJsOptions}
+        - inspect?: nodejs debugger port, 填 9229 端口 (或者传 true) 可以用临时配置来调试
+        - break?: 在第一行停止 */
+export async function launch_nodejs(js, args, options) {
+    return launch(exe_nodejs, get_nodejs_args(js, args, options), options);
+}
+function get_nodejs_args(js, args = [], { inspect, break: _break } = {}) {
+    return [
         '--enable-source-maps',
         ...inspect ? [`--inspect${_break ? '-brk' : ''}=localhost:${inspect === true ? 9229 : inspect}`] : [],
         js,
         ...args
-    ], options);
+    ];
+}
+/** 可选的向子进程输入内容，并等待子进程输出特定的内容，类似一次无返回值，仅有完成状态的 rpc 调用
+    根据文本内容匹配其实不太好，实在是没有别的 rpc 方法再使用吧
+    - ps: 子进程
+    - pattern: 匹配内容，支持 string 和 RegExp
+    - input?: 要输入的内容
+    - timeout?: 等待超时时间 */
+export async function wait_output(ps, pattern, input, _timeout) {
+    const { stdin, stdout } = ps;
+    const matcher = typeof pattern === 'string'
+        ? (chunk) => chunk.includes(pattern)
+        : (chunk) => pattern.test(chunk);
+    let on_data;
+    let pfound = new Promise(resolve => {
+        on_data = (chunk) => {
+            if (matcher(chunk)) {
+                stdout.off('data', on_data);
+                resolve();
+            }
+        };
+        stdout.on('data', on_data);
+        if (input)
+            stdin.write(input);
+    });
+    if (_timeout)
+        try {
+            await timeout(_timeout, pfound);
+        }
+        catch (error) {
+            stdout.off('data', on_data);
+            throw error;
+        }
+    else
+        await pfound;
 }
 const short_exe_names = {
     [exe_nodejs]: 'node',

package/server.d.ts

@@ -53,7 +53,6 @@ export declare class Server {
     websocket_server?: WebSocketServer;
     /** 设置后会启用 websocket rpc */
     remote?: Remote;
-    colors: boolean;
     /** 输出日志时包含日期 */
     log_date: boolean;
     /** 启用后增加 stdio 订阅相关的 remote.funcs */
@@ -65,6 +64,7 @@ export declare class Server {
     /** 原始 process.stdout.write 函数 bind 后的备份 */
     stdout_write: Function;
     stderr_write: Function;
+    url_width: 52;
     constructor({ name, print, http, http2, http_port, http2_port, fpd_certs, default_hostnames, remote, funcs, stdio_subscribable, log_date }: {
         name: string;
         print?: boolean | {

package/server.js

@@ -4,7 +4,6 @@ import { createSecureContext } from 'tls';
 import zlib from 'zlib';
 import fs from 'fs';
 import { buffer as stream_to_buffer } from 'stream/consumers';
-import util from 'util';
 import node_sea from 'node:sea';
 import { default as Koa } from 'koa';
 import KoaCors from '@koa/cors';
@@ -15,7 +14,7 @@ import { contentType as get_content_type } from 'mime-types';
 // --- my libs
 import { t } from "./i18n/instance.js";
 import { request as _request, Remote } from "./net.js";
-import { inspect, output_width, check, range_to_numbers, encode, filter_keys, filter_values, consume_stream } from "./utils.js";
+import { inspect, check, range_to_numbers, encode, filter_keys, filter_values, consume_stream } from "./utils.js";
 import { flist, fread, fstat } from "./file.js";
 import { exe_nodejs, sea } from "./process.js";
 // ------------ my server
@@ -57,7 +56,6 @@ export class Server {
     websocket_server;
     /** 设置后会启用 websocket rpc */
     remote;
-    colors = util.inspect.defaultOptions.colors;
     /** 输出日志时包含日期 */
     log_date = false;
     /** 启用后增加 stdio 订阅相关的 remote.funcs */
@@ -66,6 +64,7 @@ export class Server {
     /** 原始 process.stdout.write 函数 bind 后的备份 */
     stdout_write;
     stderr_write;
+    url_width = 52;
     constructor({ name, print, http, http2, http_port, http2_port, fpd_certs, default_hostnames, remote, funcs, stdio_subscribable, log_date }) {
         this.name = name;
         if (print !== undefined) {
@@ -278,22 +277,23 @@ export class Server {
         // url 只有路径部分
         const { url, headers, headers: { host = '' }, } = request;
         if (this.print.logs) {
-            const ip = request.socket.remoteAddress.replace(/^::ffff:/, '');
-            console.log(
+            let s = 
             // 时间
             `${this.log_date ? new Date().to_str() : new Date().to_time_str()}  ` +
-                // ip（位置）
-                (ip || '').limit(40) + '  ' +
-                // ua
-                this.format_ua(headers).limit(56) + '  ' +
-                // https／2.0
-                `${this.colors ? 'websocket'.limit(10).magenta : 'websocket'.limit(10)}  ` +
-                // method
-                ''.limit(6) + ' ' +
+                // wss://
+                `${`ws${socket.encrypted ? 's' : ''}`.yellow}://` +
                 // host
-                `${host.limit(24)}  ` +
+                host +
                 // path
-                (this.colors ? url.yellow : url));
+                url;
+            s = s.pad(this.url_width);
+            // ip
+            s += `  <-  ${request.socket.remoteAddress.strip_if_start('::ffff:')}`;
+            // ua
+            const ua = this.format_ua(headers);
+            if (ua)
+                s += `／${ua}`;
+            console.log(s);
         }
         switch (url) {
             case '/':
@@ -304,7 +304,7 @@ export class Server {
                 return;
             default:
                 if (this.print.logs)
-                    console.log(`${' '.repeat(13)}    connect 404: ${url}`.red);
+                    console.log(`未知路径的 upgrade 请求: ${url}`.red);
                 socket.destroy();
         }
     }
@@ -381,7 +381,6 @@ export class Server {
         return true;
     }
     logger(ctx) {
-        const { colors } = this;
         const { request } = ctx;
         const { query: queries, body, path, _path, protocol, host, req: { httpVersion: http_version }, ip, headers, } = request;
         let { method } = request;
@@ -390,28 +389,22 @@ export class Server {
         let s = '';
         // 时间
         s += `${this.log_date ? new Date().to_str() : new Date().to_time_str()}  `;
-        // ip（位置）
-        s += (ip || '').limit(40) + '  ';
-        // ua
-        s += this.process_ua(ctx).limit(56) + '  ';
-        // https／2.0
-        s += `${`${protocol.limit(5)} ${http_version}`.limit(10)}  `;
         // method
         method = method.toLowerCase();
-        let t = method.limit(6) + ' ';
-        if (colors && method !== 'get')
-            method = t.yellow;
-        s += t;
+        if (method !== 'get')
+            s += `${method.yellow} `;
+        // http, https, http2, websocket
+        s += `${http_version === '2.0' ? 'https'.magenta : protocol}://`;
         // host
-        s += `${host.limit(24)}  `;
+        s += host;
         // path
-        s += (() => {
-            if (path.toLowerCase() !== _path.toLowerCase())
-                return `${_path.blue} -> ${path}`;
-            if (!path.includes('.'))
-                return colors ? path.yellow : path;
-            return path;
-        })();
+        s += path.toLowerCase() !== _path.toLowerCase()
+            ? _path === '/'
+                ? '/'.blue
+                : `${_path} -> ${path}`
+            : path.includes('.')
+                ? path
+                : path.yellow;
         // range
         let range = headers.range;
         if (headers.range) {
@@ -422,14 +415,21 @@ export class Server {
                 end = Number(end).to_fsize_str();
             s += ` (${start} - ${end || ''})`;
         }
+        s += ' ';
         // queries
         if (Object.keys(queries).length) {
-            let t = inspect(queries, { compact: true })
+            s += inspect(queries, { compact: true })
                 .replace('[Object: null prototype] ', '')
                 .strip_if_end('\n');
-            s += (s + t).width > output_width ? '\n' : '    ';
-            s += t;
+            s += ' ';
         }
+        s = s.pad(this.url_width);
+        // ip
+        s += `  <-  ${ip.strip_if_start('::ffff:')}`;
+        // ua
+        const ua = this.process_ua(ctx);
+        if (ua)
+            s += `／${ua}`;
         // body
         if (body && Object.keys(body).length)
             s += '\n' + inspect(body).replace('[Object: null prototype] ', '');

package/utils.browser.d.ts

@@ -25,10 +25,12 @@ export declare class TimeoutError extends Error {
     name: "TimeoutError";
 }
 /** 在指定的时间 (milliseconds) 内运行某个任务，超时之后
-    - 如果传入了 on_timeout 参数: 调用 on_timeout，返回 null
-    - 如果没传入 on_timeout 参数: 抛出 TimeoutError
+    - action?: 要等待运行的任务, async function 或 promise
+    - on_timeout?: 超时后调用的函数
+        - 如果传入了 on_timeout 参数: 调用 on_timeout，然后 timeout 函数正常返回 null
+        - 如果没传入 on_timeout 参数: 抛出 TimeoutError
     - print?: 打印已超时任务的错误 */
-export declare function timeout<TReturn>(milliseconds: number, action: () => Promise<TReturn>, on_timeout?: () => void | Promise<void>, print?: boolean): Promise<TReturn>;
+export declare function timeout<TReturn>(milliseconds: number, action: Promise<TReturn> | (() => Promise<TReturn>), on_timeout?: () => void | Promise<void>, print?: boolean): Promise<TReturn>;
 /** https://stackoverflow.com/questions/63297164/how-to-only-accept-arraybuffer-as-parameter */
 export type StrictArrayBuffer = ArrayBuffer & {
     buffer?: undefined;
@@ -79,7 +81,7 @@ export declare function encode(str: string): Uint8Array<ArrayBufferLike>;
     在流式处理 (buffer 可能不完整) 时，应使用独立的 TextDecoder 实例调用 decode(buffer, { stream: true }) */
 export declare function decode(buffer: Uint8Array): string;
 /** 字符串字典序比较 */
-export declare function strcmp(l: string, r: string): 1 | 0 | -1;
+export declare function strcmp(l: string, r: string): 0 | 1 | -1;
 /** 比较 1.10.02 这种版本号
     - l, r: 两个版本号字符串
     - loose?: 宽松模式，允许两个版本号格式（位数）不一致 */

package/utils.browser.js

@@ -77,8 +77,10 @@ export class TimeoutError extends Error {
     name = 'TimeoutError';
 }
 /** 在指定的时间 (milliseconds) 内运行某个任务，超时之后
-    - 如果传入了 on_timeout 参数: 调用 on_timeout，返回 null
-    - 如果没传入 on_timeout 参数: 抛出 TimeoutError
+    - action?: 要等待运行的任务, async function 或 promise
+    - on_timeout?: 超时后调用的函数
+        - 如果传入了 on_timeout 参数: 调用 on_timeout，然后 timeout 函数正常返回 null
+        - 如果没传入 on_timeout 参数: 抛出 TimeoutError
     - print?: 打印已超时任务的错误 */
 export async function timeout(milliseconds, action, on_timeout, print = true) {
     const error = new TimeoutError();
@@ -108,7 +110,7 @@ export async function timeout(milliseconds, action, on_timeout, print = true) {
         })();
         (async () => {
             try {
-                resolve(await action());
+                resolve(await (typeof action === 'function' ? action() : action));
             }
             catch (error) {
                 if (rejected) {

package/utils.d.ts

@@ -3,8 +3,8 @@ import util from 'util';
 import type { TimerOptions } from 'timers';
 import type Vinyl from 'vinyl';
 import { type Mapper } from './prototype.ts';
-/** `230` term 字符宽度 （实际上有 240） */
-export declare const output_width = 230;
+/** `180` 输出字符宽度 */
+export declare const output_width = 180;
 export declare function set_inspect_options(colors?: boolean): void;
 export declare function assert<T>(assertion: T, message?: string): T;
 /** 做参数校验，逻辑检查 */
@@ -40,7 +40,7 @@ export declare function filter_values<TObj extends Record<string, any>>(obj: TOb
 /** 忽略对象中的 keys, 返回新对象 */
 export declare function omit<TObj>(obj: TObj, omit_keys: string[]): TObj;
 /** 字符串字典序比较 */
-export declare function strcmp(l: string, r: string): 1 | 0 | -1;
+export declare function strcmp(l: string, r: string): 0 | 1 | -1;
 /** 比较 1.10.02 这种版本号
     - l, r: 两个版本号字符串
     - loose?: 宽松模式，允许两个版本号格式（位数）不一致 */
@@ -91,10 +91,12 @@ export declare class TimeoutError extends Error {
     name: "TimeoutError";
 }
 /** 在指定的时间 (milliseconds) 内运行某个任务，超时之后
-    - 如果传入了 on_timeout 参数: 调用 on_timeout，返回 null
-    - 如果没传入 on_timeout 参数: 抛出 TimeoutError
+    - action?: 要等待运行的任务, async function 或 promise
+    - on_timeout?: 超时后调用的函数
+        - 如果传入了 on_timeout 参数: 调用 on_timeout，然后 timeout 函数正常返回 null
+        - 如果没传入 on_timeout 参数: 抛出 TimeoutError
     - print?: 打印已超时任务的错误 */
-export declare function timeout<TReturn>(milliseconds: number, action: () => Promise<TReturn>, on_timeout?: () => void | Promise<void>, print?: boolean): Promise<TReturn>;
+export declare function timeout<TReturn>(milliseconds: number, action: Promise<TReturn> | (() => Promise<TReturn>), on_timeout?: () => void | Promise<void>, print?: boolean): Promise<TReturn>;
 /** https://stackoverflow.com/questions/63297164/how-to-only-accept-arraybuffer-as-parameter */
 export type StrictArrayBuffer = ArrayBuffer & {
     buffer?: undefined;

package/utils.js

@@ -3,8 +3,8 @@ import util from 'util';
 import timers from 'timers/promises';
 import { t } from "./i18n/instance.js";
 import { build_mapper, not_empty, is_key_type, noop, ident } from "./prototype.js";
-/** `230` term 字符宽度 （实际上有 240） */
-export const output_width = 230;
+/** `180` 输出字符宽度 */
+export const output_width = 180;
 export function set_inspect_options(colors = true) {
     util.inspect.defaultOptions.maxArrayLength = 40;
     util.inspect.defaultOptions.maxStringLength = 10000;
@@ -281,8 +281,10 @@ export class TimeoutError extends Error {
     name = 'TimeoutError';
 }
 /** 在指定的时间 (milliseconds) 内运行某个任务，超时之后
-    - 如果传入了 on_timeout 参数: 调用 on_timeout，返回 null
-    - 如果没传入 on_timeout 参数: 抛出 TimeoutError
+    - action?: 要等待运行的任务, async function 或 promise
+    - on_timeout?: 超时后调用的函数
+        - 如果传入了 on_timeout 参数: 调用 on_timeout，然后 timeout 函数正常返回 null
+        - 如果没传入 on_timeout 参数: 抛出 TimeoutError
     - print?: 打印已超时任务的错误 */
 export async function timeout(milliseconds, action, on_timeout, print = true) {
     const error = new TimeoutError();
@@ -312,7 +314,7 @@ export async function timeout(milliseconds, action, on_timeout, print = true) {
         })();
         (async () => {
             try {
-                resolve(await action());
+                resolve(await (typeof action === 'function' ? action() : action));
             }
             catch (error) {
                 if (rejected) {