xshell 1.0.202 → 1.0.203

package/net.d.ts

@@ -54,6 +54,10 @@ export interface RequestOptions {
     cookies?: Record<string, string>;
     redirect?: 'follow' | 'manual';
     decode?: boolean;
+    print?: {
+        retry: boolean;
+        timeout: boolean;
+    };
 }
 export interface RequestFullOptions extends RequestOptions {
     full: true;
@@ -92,7 +96,10 @@ export interface RequestError extends Error {
         - cookies?: 需要额外添加到请求的 cookies, 默认情况下携带了 MemoryCookieStore 中保存的之前 http 响应中的 cookies
         - raw?: `false` 传入后返回整个 response (RawResponse)，body 为 Readable
         - full?: `false` 传入后返回整个 response (FullResponse)，body 根据 encoding 对应为 string 或 Buffer
-        - decode?: 根据 content-encoding: br 等解码压缩后的 response.body */
+        - decode?: 根据 content-encoding: br 等解码压缩后的 response.body
+        - print?:
+            - retry: `true` 是否打印 "等待 1 秒后重试 request" 提示信息
+            - timeout: `true` 是否打印最后一次超时重试失败时的错误  */
 export declare function request(url: string | URL): Promise<string>;
 export declare function request(url: string | URL, options: RequestRawOptions): Promise<RawResponse>;
 export declare function request(url: string | URL, options: RequestFullOptions & {

package/net.js

@@ -38,7 +38,7 @@ const drop_request_headers = new Set([
     'upgrade',
 ]);
 let agents = {};
-async function request_retry(url, options, _timeout, retries = 0, count = 0) {
+async function request_retry(url, options, _timeout, retries = 0, count = 0, print) {
     let { default: undici, request: undici_request } = await import('undici');
     undici_request ??= undici.request;
     try {
@@ -46,7 +46,7 @@ async function request_retry(url, options, _timeout, retries = 0, count = 0) {
             // 设置给 undici 设置 timeout, signal 不一定管用，还是得自己兜底
             options.signal = AbortSignal.timeout(_timeout);
             return await timeout(_timeout + 300, // 为 undici 兜底
-            async () => undici.request(url, options), undefined, count >= retries // 只打印最后一次超时的错误，避免太多冗余输出
+            async () => undici.request(url, options), undefined, print.timeout && count >= retries // 只打印最后一次超时的错误，避免太多冗余输出
             );
         }
         else
@@ -56,9 +56,10 @@ async function request_retry(url, options, _timeout, retries = 0, count = 0) {
         if (error.name === 'TimeoutError')
             if (count < retries) {
                 const duration = 2 ** count;
-                console.log(`${t('等待 {{duration}} 秒后重试 request (已尝试 {{_count}} 次) …', { duration, _count: count + 1 }).yellow}  ${url.toString().blue.underline}`);
+                if (print.retry)
+                    console.log(`${t('等待 {{duration}} 秒后重试 request (已尝试 {{_count}} 次) …', { duration, _count: count + 1 }).yellow}  ${url.toString().blue.underline}`);
                 await delay(1000 * duration);
-                return request_retry(url, options, _timeout, retries, count + 1);
+                return request_retry(url, options, _timeout, retries, count + 1, print);
             }
             else
                 throw Object.assign(new Error(`request 超时: ${url.toString()}`), { name: 'TimeoutError' });
@@ -72,7 +73,10 @@ export async function request(url, options = {}) {
     FormData ??= undici.FormData;
     const { Cookie } = await import('tough-cookie');
     await cookies.init();
-    const { queries, headers: _headers, body, type = 'application/json', timeout = 5 * 1000, auth, cookies: _cookies, raw = false, full = false, redirect = 'follow', decode = true, } = options;
+    const { queries, headers: _headers, body, type = 'application/json', timeout = 5 * 1000, auth, cookies: _cookies, raw = false, full = false, redirect = 'follow', decode = true, print = {
+        timeout: true,
+        retry: true
+    } } = options;
     let { method, retries, encoding, proxy, } = options;
     url = new URL(url);
     if (queries)
@@ -179,7 +183,7 @@ export async function request(url, options = {}) {
     };
     let response;
     try {
-        const { statusCode: status, headers: _headers, body: _body } = await request_retry(url, undici_options, timeout, retries);
+        const { statusCode: status, headers: _headers, body: _body } = await request_retry(url, undici_options, timeout, retries, 0, print);
         // 处理 cookie，自动保存到 cookie jar
         let _cookies = _headers['set-cookie'] || [];
         if (typeof _cookies === 'string')

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "xshell",
-    "version": "1.0.202",
+    "version": "1.0.203",
     "type": "module",
     "main": "./index.js",
     "bin": {
@@ -105,7 +105,7 @@
         "tslib": "^2.8.1",
         "typescript": "^5.7.2",
         "ua-parser-js": "^2.0.0",
-        "undici": "^7.0.0-alpha.7",
+        "undici": "^7.0.0",
         "vinyl": "^3.0.0",
         "vinyl-fs": "^4.0.0",
         "webpack": "^5.96.1",

package/path.d.ts

@@ -55,7 +55,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. */
@@ -83,7 +83,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

@@ -2,7 +2,6 @@ import { type ChildProcess } from 'child_process';
 import './prototype.ts';
 import type { Encoding } from './file.ts';
 import type { MyProxy } from './net.ts';
-import { inspect } from './utils.ts';
 export declare const exe_nodejs: string;
 export declare const platform: NodeJS.Platform;
 export declare const username: string;
@@ -18,35 +17,25 @@ export declare const print_no_command: {
     };
 };
 type StdioType = 'pipe' | 'ignore' | 'inherit' | number;
-interface StartOptions {
-    /** `继承当前工作目录 process.cwd()` 子进程的工作目录  `inherit the cwd` cwd of the child process. */
+export interface FullPrintOptions {
+    stdout: boolean;
+    stderr: boolean;
+    command: boolean;
+    /** 进程执行成功的消息 */
+    code: boolean;
+}
+interface BaseOptions {
     cwd?: string;
     /** `process.env` 覆盖/添加到 process.env 的环境变量 */
     envs?: Record<string, string>;
     /** 创建子进程时添加 http_proxy, https_proxy, no_proxy 环境变量以启用代理 */
     proxy?: MyProxy | true;
-    /** `'utf-8'` 子进程输出编码  child output encoding */
-    encoding?: Encoding | 'binary';
-    /** `true` print 选项，支持设置细项  print option (with details) */
-    print?: boolean | {
-        stdout: boolean;
-        stderr: boolean;
-        command: boolean;
-        /** 进程执行成功的消息 */
-        code: boolean;
-    };
-    /** `'pipe'` 设置为 'ignore' 时忽略 stdio 处理 */
-    stdio?: 'pipe' | 'ignore' | [StdioType, StdioType, StdioType];
-    /** 启动子进程之后写入到子进程 stdin 中的内容，写完后关闭子进程 stdin (pty 不关闭) */
-    input?: string;
     /** 使用文件作为标准输入 */
     fp_stdin?: string;
     /** 使用文件作为标准输出 */
     fp_stdout?: string;
     /** 使用文件作为标准错误 */
     fp_stderr?: string;
-    /** `false` 是否断开和 child 的关系 (ignore stdio, unref)  whether to break the connection with child (ignore stdio, unref) */
-    detached?: boolean;
     /** 为 true 时会设置 UV_PROCESS_WINDOWS_HIDE
         然后设置启动进程的参数 CREATE_NO_WINDOW, 和 SW_HIDE
         D:/0/libuv/src/win/process.c
@@ -59,29 +48,47 @@ interface StartOptions {
         具体有什么用还不清楚 */
     window?: boolean;
 }
-/** start process
-    - exe: .exe 路径或文件名 (建议使用完整路径，跳过 path 搜索，性能更高)  path or filename (full path is recommanded to skip path searching for better perf)
-    - args: `[]` 参数列表  arguments list
-    - options
-        - cwd?: `继承当前工作目录 process.cwd()` 子进程的工作目录  `inherit the cwd` cwd of the child process.
+export interface StartOptions extends BaseOptions {
+    /** `true` 是否打印启动命令行 */
+    print?: boolean;
+    /** 使用文件作为标准输入 */
+    fp_stdin?: string;
+    /** 使用文件作为标准输出 */
+    fp_stdout?: string;
+    /** 使用文件作为标准错误 */
+    fp_stderr?: string;
+}
+/** 启动独立的进程，不受当前 node.js 进程退出的影响
+    - exe: .exe 路径或文件名 (建议使用完整路径，跳过 path 搜索，性能更高)
+    - args?: `[ ]` 参数列表
+    - options?:
+        - cwd?
         - envs?: `process.env` 覆盖／添加到 process.env 的环境变量，传 null 时可以取消设置该变量
-        - encoding?: `'utf-8'` 子进程输出编码  child output encoding
-        - print?: `true` print 选项，支持设置细项  print option (with details)
-        - stdio?: `'pipe'` 设置为 'ignore' 时忽略 stdio 处理  when 'ignore' then ignore stdio processing
+        - encoding?: `'utf-8'` 子进程输出编码
+        - print?: `true` 是否打印启动命令行
+        - stdio?: `'pipe'` 设置为 'ignore' 时忽略 stdio 处理
         - input?: string, 启动子进程之后写入到子进程 stdin 中的内容，写完后关闭子进程 stdin (pty 不关闭)
-        - fp_stdin?: 使用文件作为标准输入，设置 stdio 中选项为对应的值
-        - fp_stdout?: 使用文件作为标准输出，设置 stdio 中选项为对应的值
-        - fp_stderr?: 使用文件作为标准错误，设置 stdio 中选项为对应的值
-        - detached?: `false` 是否断开和 child 的关系 (ignore stdio, unref)  whether to break the connection with child (ignore stdio, unref) */
+        - 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_nodejs(js: string, args?: string[], options?: StartOptions): Promise<ChildProcess>;
-export interface CallOptions extends StartOptions {
+export interface CallOptions extends BaseOptions {
+    /** `true` print 选项，支持设置细项 */
+    print?: boolean | FullPrintOptions;
+    /** `true` code 不为 0 时是否抛出异常 */
     throw_code?: boolean;
+    /** `'utf-8'` 子进程输出编码 */
+    encoding?: 'binary' | Encoding;
+    /** `'pipe'` 设置为 'ignore' 时忽略 stdio 处理 */
+    stdio?: 'pipe' | 'ignore' | [StdioType, StdioType, StdioType];
+    /** 启动子进程之后写入到子进程 stdin 中的内容，写完后关闭子进程 stdin */
     input?: string;
+    /** 实时处理 stdout 和 stderr 的每个 chunk，启用后子进程输出不会自动 print */
     printers?: {
         stdout?: (chunk: string) => void;
         stderr?: (chunk: string) => void;
     };
+    /** 可以传入回调函数及时获取通过 start 创建的子进程，便于执行 kill、获得 pid 等操作 */
     on_child?: (child: ChildProcess) => void;
 }
 export interface CallResult<TOutput extends string | Buffer = string> {
@@ -91,83 +98,63 @@ export interface CallResult<TOutput extends string | Buffer = string> {
     code: number | null;
     signal: NodeJS.Signals | null;
     child: ChildProcess;
-    [inspect.custom](): string;
 }
-export interface CallError {
+export interface CallError<TOutput extends string | Buffer = string> {
     result: {
         pid: number;
-        stdout: string;
-        stderr: string;
+        stdout: TOutput;
+        stderr: TOutput;
         code: number;
-        signal: number | NodeJS.Signals;
+        signal: NodeJS.Signals;
         child: ChildProcess;
     };
 }
-/** call process for result
-    - exe: .exe 路径或文件名 (建议使用路径，跳过 path 搜索，性能更高)  path or filename (full path is recommanded to skip path searching for better perf)
-    - args: `[]` 参数列表  arguments list
+/** 调用可执行文件，获取返回结果
+    - exe: .exe 路径或文件名 (建议使用路径，跳过 path 搜索，性能更高)
+    - args: `[ ]` 参数列表
     - options?:
-        - cwd?: `process.cwd()`
+        - cwd?
         - envs?: `process.env` 覆盖／添加到 process.env 的环境变量，传 null 时可以取消设置该变量
         - encoding?: `'utf-8'` 子进程输出编码, 设置为 binary 时返回 stdout, stderr 类型为 Buffer; 否则是 string
-            child output encoding. When set to binary, return stdout, stderr is of type Buffer; otherwise it is string
-        - print?: `true` print 选项，支持设置细项  print option (with details)
-        - printers?: 实时处理 stdout 和 stderr 的每个 chunk
-        - stdio?: `'pipe'` 设置为 'ignore' 时忽略 stdio 处理  when 'ignore' then ignore stdio processing
-        - input?: string, 启动子进程之后写入到子进程 stdin 中的内容，写完后关闭子进程 stdin (pty 不关闭)
-        - detached?: `false` 是否断开和 child 的关系 (ignore stdio, unref)  whether to break the connection with child (ignore stdio, unref)
-        - throw_code?: `true` code 不为 0 时是否抛出异常  whether to throw Error when code is not 0
-        - on_child: 可以传入回调函数及时获取通过 start 创建的子进程，便于执行 kill、获得 pid 等操作 */
-export declare function call(exe: string, args?: string[]): Promise<CallResult<string>>;
-export declare function call(exe: string, args?: string[], options?: CallOptions & {
-    encoding: 'binary';
-}): Promise<CallResult<Buffer>>;
+        - print?: `true` print 选项，支持设置细项
+        - printers?: 实时处理 stdout 和 stderr 的每个 chunk，启用后子进程输出不会自动 print，且对应的 stdout, stderr 为空
+        - stdio?: `'pipe'` 设置为 'ignore' 时忽略 stdio 处理
+        - input?: string, 启动子进程之后写入到子进程 stdin 中的内容，写完后关闭子进程 stdin
+        - throw_code?: `true` code 不为 0 时是否抛出异常
+        - on_child?: 可以传入回调函数及时获取通过 start 创建的子进程，便于执行 kill、获得 pid 等操作 */
 export declare function call(exe: string, args?: string[], options?: CallOptions): Promise<CallResult<string>>;
 export interface CallNodeJsOptions extends CallOptions {
-    inspect?: number;
+    inspect?: number | true;
     break?: boolean;
 }
-/** call node <js> for result
-    - js: .js 路径 (相对路径根据 cwd 解析)  path (relative path will resolve based on cwd)
-    - args: `[]` 参数列表  arguments list
-    - options
-        - cwd?: `process.cwd()`
-        - envs?: `process.env` 覆盖／添加到 process.env 的环境变量  overwrite/add to process.env
-        - encoding?: `'utf-8'` 子进程输出编码  child process output encoding
-        - print?: `true` print 选项，支持设置细项  print option (with details)
-        - stdio?: `'pipe'` 设置为 'ignore' 时忽略 stdio 处理  when 'ignore' then ignore stdio processing
-        - detached?: `false` 是否断开和 child 的关系 (ignore stdio, unref)  whether to break the connection with child (ignore stdio, unref)
+/** 调用 node <js> 并等待结果
+    - js: .js 路径 (相对路径根据 cwd 解析)
+    - args?: `[ ]` 参数列表
+    - options?:
+        - cwd?: `'T:/'`
+        - envs?: `process.env` 覆盖／添加到 process.env 的环境变量
+        - encoding?: `'utf-8'` 子进程输出编码
+        - print?: `true` print 选项，支持设置细项
+        - stdio?: `'pipe'` 设置为 'ignore' 时忽略 stdio 处理
         - throw_code?: `true` code 不为 0 时是否抛出异常
-        - inspect?: nodejs debugger port
+        - 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 TermOptions {
-    /** `process.cwd()` */
-    cwd?: string;
-    /** `true` 打印参数 */
-    print?: boolean;
-    title?: string;
-    /** `process.env` 覆盖/添加到 process.env 的环境变量 */
-    envs?: Record<string, string>;
-}
-export declare const exe_winterm: string;
-/** 新建 terminal 窗口执行进程  New Terminal window execution process
-    - exe: exe 文件路径  exe file path
-    - args: 调用参数  call parameter
-    - options?: WinTermOptions */
-export declare function term(exe: string, args?: string[], { cwd, print, title, envs }?: TermOptions): Promise<ChildProcess>;
-export interface TermNodeOptions extends TermOptions {
-    /** nodejs debugger port */
-    inspect?: number;
-    /** break at first line */
+export interface StartNodeJsOptions extends StartOptions {
+    inspect?: number | true;
     break?: boolean;
-    /** 使用 ts-node 直接运行  use ts-node to run directly */
-    tsnode?: boolean;
-    /** `false` --experimental-specifier-resolution=node */
-    resolve?: boolean;
-    /** `false` --trace-warnings */
-    trace_warnings?: boolean;
 }
-/** 在 term tab 中创建 node.exe 进程 */
-export declare function term_nodejs(fp_js: string, args?: string[], { title, inspect, tsnode, break: _break, resolve, trace_warnings, ...options }?: TermNodeOptions): Promise<ChildProcess>;
+/** 启动 node <js>
+    - js: .js 路径 (相对路径根据 cwd 解析)
+    - args: `[]` 参数列表
+    - options
+        - cwd?: `'T:/'`
+        - envs?: `process.env` 覆盖／添加到 process.env 的环境变量
+        - encoding?: `'utf-8'` 子进程输出编码
+        - print?: `true` print 选项，支持设置细项
+        - stdio?: `'pipe'` 设置为 'ignore' 时忽略 stdio 处理
+        - detached?: `false` 是否断开和 child 的关系 (ignore stdio, unref)
+        - 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>;
 export {};

package/process.js

@@ -1,42 +1,50 @@
 import { spawn } from 'child_process';
 import os from 'os';
-import { t } from "./i18n/instance.js";
 import "./prototype.js";
-import { inspect, DecoderStream, filter_values, assert, check } from "./utils.js";
+import { inspect, DecoderStream, filter_values, check } from "./utils.js";
 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 } };
-/** start process
-    - exe: .exe 路径或文件名 (建议使用完整路径，跳过 path 搜索，性能更高)  path or filename (full path is recommanded to skip path searching for better perf)
-    - args: `[]` 参数列表  arguments list
-    - options
-        - cwd?: `继承当前工作目录 process.cwd()` 子进程的工作目录  `inherit the cwd` cwd of the child process.
-        - envs?: `process.env` 覆盖／添加到 process.env 的环境变量，传 null 时可以取消设置该变量
-        - encoding?: `'utf-8'` 子进程输出编码  child output encoding
-        - print?: `true` print 选项，支持设置细项  print option (with details)
-        - stdio?: `'pipe'` 设置为 'ignore' 时忽略 stdio 处理  when 'ignore' then ignore stdio processing
-        - input?: string, 启动子进程之后写入到子进程 stdin 中的内容，写完后关闭子进程 stdin (pty 不关闭)
-        - fp_stdin?: 使用文件作为标准输入，设置 stdio 中选项为对应的值
-        - fp_stdout?: 使用文件作为标准输出，设置 stdio 中选项为对应的值
-        - fp_stderr?: 使用文件作为标准错误，设置 stdio 中选项为对应的值
-        - detached?: `false` 是否断开和 child 的关系 (ignore stdio, unref)  whether to break the connection with child (ignore stdio, unref) */
-export async function start(exe, args = [], options = {}) {
-    const { cwd, encoding = 'utf-8', detached = false, window: _window = true, envs, input, fp_stdin, fp_stdout, fp_stderr } = options;
-    let { print = true, stdio = detached ? 'ignore' : 'pipe', proxy } = options;
+async function prepare_spawn(detached, exe, args, { cwd, window: _window = true, envs, 
+// @ts-ignore
+input, fp_stdin, fp_stdout, fp_stderr, print = true, proxy, 
+// @ts-ignore
+stdio }) {
+    // --- 处理 proxy, envs
     if (proxy === true) {
         const { MyProxy } = await import("./net.js");
         proxy = MyProxy.socks5;
     }
-    if (typeof stdio === 'string')
-        stdio = [stdio, stdio, stdio];
-    if (input)
-        assert(!fp_stdin, 'input 和 fp_stdin 不能同时设置');
+    let envs_;
+    if (envs || proxy)
+        envs_ = filter_values({
+            ...process.env,
+            ...proxy ? {
+                http_proxy: proxy,
+                https_proxy: proxy,
+                no_proxy: '127.0.0.1,::1,localhost,192.168.0.0/20,192.168.100.0/24'
+            } : {},
+            ...envs
+        });
+    // --- 处理 stdio
+    if (input && fp_stdin)
+        throw new Error('input 和 fp_stdin 不能同时设置');
     let opened_handles = [];
     async function close_all_handles() {
         await Promise.all(opened_handles.map(async (handle) => handle.close()));
     }
+    if (Array.isArray(stdio)) {
+        if (input)
+            check(stdio[0] === 'pipe', '传入 input 时 stdio[0] 应该是 pipe');
+    }
+    else if (typeof stdio === 'string')
+        stdio = [stdio, stdio, stdio];
+    else if (detached)
+        stdio = ['ignore', 'ignore', 'ignore'];
+    else
+        stdio = [input ? 'pipe' : 'ignore', 'pipe', 'pipe'];
     if (fp_stdin || fp_stdout || fp_stderr) {
         const { fopen } = await import("./file.js");
         async function open(fp, flags) {
@@ -59,168 +67,145 @@ export async function start(exe, args = [], options = {}) {
                 ? stdio[1]
                 : await open(fp_stderr, 'w');
     }
-    const options_ = {
-        cwd,
-        shell: false,
-        windowsHide: !_window,
-        detached,
-        stdio,
-        ...envs || proxy ? {
-            env: filter_values({
-                ...process.env,
-                ...proxy ? {
-                    http_proxy: proxy,
-                    https_proxy: proxy,
-                    no_proxy: '127.0.0.1,::1,localhost,192.168.0.0/20,192.168.100.0/24'
-                } : {},
-                ...envs
-            })
-        } : {},
-    };
+    if (detached)
+        check(stdio.every((x) => x === 'ignore' || typeof x === 'number'), '调用 start 时 stdio 只能是 fd 或者 ignore');
     if (typeof print === 'boolean')
         print = {
-            stdout: print,
-            stderr: print,
             command: print,
             code: print,
+            stdout: print,
+            stderr: print
         };
+    let command;
     if (print.command)
-        console.log(((short_exe_names[exe] || exe.quote_if_space()) +
-            (args.length ?
-                ' ' + args.filter(arg => arg !== '--suppressApplicationTitle')
-                    .map(arg => arg.quote_if_space())
-                    .join(' ')
-                :
-                    '')).blue);
-    if (detached) {
-        check(stdio.every(x => x === 'ignore' || typeof x === 'number'), '调用 start({ detached: true }) 时 stdio 只能是 fd 或者 ignore');
-        try {
-            let child = spawn(exe, args, options_);
-            child.unref();
-            return child;
-        }
-        finally {
-            if (opened_handles.length)
-                await close_all_handles();
-        }
+        console.log((command =
+            (short_exe_names[exe] || exe.quote_if_space()) +
+                (args.length
+                    ? ' ' + args
+                        .map(arg => arg.quote_if_space())
+                        .join(' ')
+                    : '')).blue);
+    return {
+        print,
+        command,
+        spawn_options: {
+            cwd,
+            shell: false,
+            // processhacker 在 windowsHide 为 true 时不显示窗口
+            windowsHide: !_window,
+            detached,
+            stdio,
+            ...envs_ ? { env: envs_ } : {}
+        },
+        close_all_handles: opened_handles.length ? close_all_handles : undefined
+    };
+}
+/** 启动独立的进程，不受当前 node.js 进程退出的影响
+    - exe: .exe 路径或文件名 (建议使用完整路径，跳过 path 搜索，性能更高)
+    - args?: `[ ]` 参数列表
+    - options?:
+        - cwd?
+        - envs?: `process.env` 覆盖／添加到 process.env 的环境变量，传 null 时可以取消设置该变量
+        - encoding?: `'utf-8'` 子进程输出编码
+        - print?: `true` 是否打印启动命令行
+        - stdio?: `'pipe'` 设置为 'ignore' 时忽略 stdio 处理
+        - input?: string, 启动子进程之后写入到子进程 stdin 中的内容，写完后关闭子进程 stdin (pty 不关闭)
+        - fp_stdin?: 使用文件作为标准输入，设置 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);
+    try {
+        let child = spawn(exe, args, spawn_options);
+        child.unref();
+        return child;
+    }
+    finally {
+        if (close_all_handles)
+            await close_all_handles();
     }
+}
+export async function call(exe, args = [], options = {}) {
+    const { print, command, spawn_options, close_all_handles } = await prepare_spawn(false, exe, args, options);
     let child;
     try {
-        child = spawn(exe, args, options_);
+        child = spawn(exe, args, spawn_options);
     }
-    catch (error) {
-        if (opened_handles.length)
+    finally {
+        if (close_all_handles)
             await close_all_handles();
-        throw error;
     }
+    const { stdio } = spawn_options;
+    const { encoding = 'utf-8', input, on_child, printers, throw_code } = options;
     // 防止 child spawn 失败时 crash nodejs 进程
     child.on('error', error => {
         console.error(error);
     });
-    if (stdio[0] === 'pipe')
-        child.stdin.setDefaultEncoding('utf8');
-    if (encoding !== 'binary') {
-        if (stdio[1] === 'pipe') {
-            if (encoding === 'utf-8')
-                child.stdout.setEncoding('utf-8');
-            else
-                child.stdout = child.stdout.pipe(new DecoderStream(encoding));
-            if (print.stdout)
-                child.stdout.pipe(process.stdout, { end: false });
-        }
-        if (stdio[2] === 'pipe') {
-            if (encoding === 'utf-8')
-                child.stderr.setEncoding('utf-8');
-            else
-                child.stderr = child.stderr.pipe(new DecoderStream(encoding));
-            if (print.stderr)
-                child.stderr.pipe(process.stderr, { end: false });
-        }
+    if (stdio[0] === 'pipe') {
+        child.stdin.setDefaultEncoding('utf-8');
+        if (input)
+            child.stdin.end(input);
     }
-    if (input)
-        child.stdin.end(input);
-    if (opened_handles.length)
-        await close_all_handles();
-    return child;
-}
-export async function start_nodejs(js, args = [], options) {
-    return start(exe_nodejs, ['--enable-source-maps', js, ...args], options);
-}
-export async function call(exe, args = [], options = {}) {
-    const { encoding = 'utf-8', throw_code = true, printers, on_child } = options;
-    let { stdio = 'pipe', print = true } = options;
-    if (typeof print === 'boolean')
-        print = {
-            command: print,
-            stdout: print,
-            stderr: print,
-            code: print,
-        };
-    if (typeof stdio === 'string')
-        stdio = [stdio, stdio, stdio];
-    const cmd = (short_exe_names[exe] || exe.quote_if_space()) +
-        (args.length ? (' ' + args.map(arg => arg.quote_if_space())
-            .join(' '))
-            :
-                '');
-    if (print.command)
-        console.log(cmd.blue);
-    let child = await start(exe, args, {
-        ...options,
-        print: false,
-    });
-    on_child?.(child);
-    // --- collect output
+    // --- 收集进程输出
     let stdouts = [];
     let stderrs = [];
-    let code, signal;
-    await Promise.all([
-        new Promise(resolve => {
-            child.once('exit', (_code, _signal) => {
-                code = _code;
-                signal = _signal;
-                resolve();
-            });
-        }),
-        (async () => {
-            if (stdio[1] === 'pipe')
-                for await (const chunk of child.stdout) {
-                    if (encoding !== 'binary' && print.stdout)
-                        if (printers?.stdout)
-                            printers.stdout(chunk);
-                        else
-                            process.stdout.write(chunk);
+    if (stdio[1] === 'pipe') {
+        if (encoding === 'utf-8')
+            child.stdout.setEncoding('utf-8');
+        else if (encoding !== 'binary')
+            child.stdout = child.stdout.pipe(new DecoderStream(encoding));
+        child.stdout.on('data', printers?.stdout
+            ? printers.stdout
+            : print.stdout
+                ? (chunk) => {
                     stdouts.push(chunk);
+                    process.stdout.write(chunk);
                 }
-        })(),
-        (async () => {
-            if (stdio[2] === 'pipe')
-                for await (const chunk of child.stderr) {
-                    if (encoding !== 'binary' && print.stderr)
-                        if (printers?.stderr)
-                            printers.stderr(chunk);
-                        else
-                            process.stderr.write(chunk);
+                : (chunk) => {
+                    stdouts.push(chunk);
+                });
+    }
+    if (stdio[2] === 'pipe') {
+        if (encoding === 'utf-8')
+            child.stderr.setEncoding('utf-8');
+        else if (encoding !== 'binary')
+            child.stderr = child.stderr.pipe(new DecoderStream(encoding));
+        child.stderr.on('data', printers?.stderr
+            ? printers.stderr
+            : print.stderr
+                ? (chunk) => {
                     stderrs.push(chunk);
+                    process.stderr.write(chunk);
                 }
-        })()
-    ]);
-    const message = `${t('进程')} ${cmd} ` + (code ?
-        `(pid: ${child.pid}) ${throw_code ? t('异常结束') : t('结束')}, code: ${code}${signal ? `, signal: ${signal}` : ''}`
-        :
-            t('正常结束'));
-    if (print.code || (throw_code && (code || signal)))
-        console.log(message[(throw_code && (code || signal)) ? 'red' : 'blue']);
+                : (chunk) => {
+                    stderrs.push(chunk);
+                });
+    }
+    on_child?.(child);
+    let code, signal;
+    await new Promise(resolve => {
+        child.once('close', (_code, _signal) => {
+            code = _code;
+            signal = _signal;
+            resolve();
+        });
+    });
+    let message;
+    const code_error = throw_code && (code || signal);
+    if (print.code || code_error) {
+        message = `进程 ${command} ` + (code
+            ? `${throw_code ? '异常' : ''}结束，退出码: ${code}${signal ? `，信号: ${signal}` : ''}`
+            : '正常结束');
+        console.log(message[code_error ? 'red' : 'blue']);
+    }
     const result = {
         pid: child.pid,
-        stdout: encoding === 'binary' ?
-            Buffer.concat(stdouts)
-            :
-                stdouts.join(''),
-        stderr: encoding === 'binary' ?
-            Buffer.concat(stderrs)
-            :
-                stderrs.join(''),
+        stdout: encoding === 'binary'
+            ? Buffer.concat(stdouts)
+            : stdouts.join(''),
+        stderr: encoding === 'binary'
+            ? Buffer.concat(stderrs)
+            : stderrs.join(''),
         code,
         signal,
         child,
@@ -228,71 +213,54 @@ export async function call(exe, args = [], options = {}) {
             return inspect(this, { omit: ['child'] });
         }
     };
-    if (code && throw_code)
-        throw Object.assign(new Error(message), { result });
+    if (code_error) {
+        let error = new Error(message);
+        error.result = result;
+        throw error;
+    }
     return result;
 }
-/** call node <js> for result
-    - js: .js 路径 (相对路径根据 cwd 解析)  path (relative path will resolve based on cwd)
-    - args: `[]` 参数列表  arguments list
-    - options
-        - cwd?: `process.cwd()`
-        - envs?: `process.env` 覆盖／添加到 process.env 的环境变量  overwrite/add to process.env
-        - encoding?: `'utf-8'` 子进程输出编码  child process output encoding
-        - print?: `true` print 选项，支持设置细项  print option (with details)
-        - stdio?: `'pipe'` 设置为 'ignore' 时忽略 stdio 处理  when 'ignore' then ignore stdio processing
-        - detached?: `false` 是否断开和 child 的关系 (ignore stdio, unref)  whether to break the connection with child (ignore stdio, unref)
+/** 调用 node <js> 并等待结果
+    - js: .js 路径 (相对路径根据 cwd 解析)
+    - args?: `[ ]` 参数列表
+    - options?:
+        - cwd?: `'T:/'`
+        - envs?: `process.env` 覆盖／添加到 process.env 的环境变量
+        - encoding?: `'utf-8'` 子进程输出编码
+        - print?: `true` print 选项，支持设置细项
+        - stdio?: `'pipe'` 设置为 'ignore' 时忽略 stdio 处理
         - throw_code?: `true` code 不为 0 时是否抛出异常
-        - inspect?: nodejs debugger port
+        - 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}`] : [],
+        ...inspect ? [`--inspect${_break ? '-brk' : ''}=localhost:${inspect === true ? 9229 : inspect}`] : [],
         js,
         ...args
     ], options);
 }
-export const exe_winterm = `C:/Users/${username}/AppData/Local/Microsoft/WindowsApps/wt.exe`;
-/** 新建 terminal 窗口执行进程  New Terminal window execution process
-    - exe: exe 文件路径  exe file path
-    - args: 调用参数  call parameter
-    - options?: WinTermOptions */
-export async function term(exe, args = [], { cwd = process.cwd().fpd, print = true, title, envs } = {}) {
-    return start(exe_winterm, [
-        'new-tab',
-        '-d', cwd,
-        ...title ? ['--suppressApplicationTitle', '--title', title] : [],
-        exe,
-        ...args.map(arg => arg.replaceAll(';', '\\;')),
-    ], {
-        print,
-        detached: true,
-        cwd,
-        envs
-    });
-}
-/** 在 term tab 中创建 node.exe 进程 */
-export async function term_nodejs(fp_js, args = [], { title, inspect, tsnode = false, break: _break, resolve = false, trace_warnings, ...options } = {}) {
-    return term(exe_nodejs, [
+/** 启动 node <js>
+    - js: .js 路径 (相对路径根据 cwd 解析)
+    - args: `[]` 参数列表
+    - options
+        - cwd?: `'T:/'`
+        - envs?: `process.env` 覆盖／添加到 process.env 的环境变量
+        - encoding?: `'utf-8'` 子进程输出编码
+        - print?: `true` print 选项，支持设置细项
+        - stdio?: `'pipe'` 设置为 'ignore' 时忽略 stdio 处理
+        - detached?: `false` 是否断开和 child 的关系 (ignore stdio, unref)
+        - 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, [
         '--enable-source-maps',
-        ...trace_warnings ?? inspect ? ['--trace-warnings'] : [],
-        ...resolve ? ['--experimental-specifier-resolution=node'] : [],
-        ...title ? [`--title=${title}`] : [],
-        ...inspect ? [`--inspect${_break ? '-brk' : ''}=localhost:${inspect}`] : [],
-        ...tsnode ? [
-            '--loader=ts-node/esm',
-            '--experimental-specifier-resolution=node'
-        ] : [],
-        fp_js,
+        ...inspect ? [`--inspect${_break ? '-brk' : ''}=localhost:${inspect === true ? 9229 : inspect}`] : [],
+        js,
         ...args
-    ], {
-        title,
-        ...options,
-    });
+    ], options);
 }
 const short_exe_names = {
-    [exe_winterm]: 'term',
     [exe_nodejs]: 'node',
 };
 //# sourceMappingURL=process.js.map

package/utils.browser.d.ts

@@ -81,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): 0 | 1 | -1;
+export declare function strcmp(l: string, r: string): 1 | 0 | -1;
 /** 比较 1.10.02 这种版本号
     - l, r: 两个版本号字符串
     - loose?: 宽松模式，允许两个版本号格式（位数）不一致 */

package/utils.d.ts

@@ -44,7 +44,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): 0 | 1 | -1;
+export declare function strcmp(l: string, r: string): 1 | 0 | -1;
 /** 比较 1.10.02 这种版本号
     - l, r: 两个版本号字符串
     - loose?: 宽松模式，允许两个版本号格式（位数）不一致 */