xshell 1.1.20 → 1.1.22

package/apps.d.ts

@@ -1,5 +1,3 @@
-import type { Readable } from 'stream';
-import type OSS from 'ali-oss';
 import { type CallOptions } from './process.ts';
 export declare let npm: {
     bin: string;
@@ -17,42 +15,3 @@ export declare let npm: {
         break?: boolean;
     }): Promise<void>;
 };
-/** 使用 tsc 编译项目
-    - fpd: 项目目录
-    - options?:
-        - tsconfig?: `'<dir>/tsconfig.json'`
-        - typecheck?: `false`  是否只进行 typecheck, (使用 call_node 执行而非 term) */
-export declare function tsc(fpd: string, { tsconfig, typecheck, }?: {
-    tsconfig?: string;
-    typecheck?: boolean;
-}): Promise<import("./process.ts").CallResult<string>>;
-export declare let oss: {
-    client: OSS;
-    bucket: string;
-    region: string;
-    fpd_cdn: string;
-    fpd_oss: string;
-    init({ bucket, region, fpd_cdn, fpd_oss, access_id, access_key }: {
-        bucket: string;
-        region: string;
-        fpd_cdn: string;
-        fpd_oss: string;
-        access_id: string;
-        access_key: string;
-    }): Promise<void>;
-    /** 上传文件到 oss，返回文件 url
-        - fp: 上传到 oss 的路径, 如 assets/web.latest.zip
-        - data: 文件 (Uint8Array) | 本地文件完整路径 (string) | ReadableStream
-        - options?:
-            - private?: `false` 设置为私有，需要通过 URL 签名参数访问
-            - print?: `true` 打印消息
-            - cdn?: `false` false 时返回 oss 链接，true 时返回 cdn 链接
-            - copy?: `false` 是否复制到剪贴板 */
-    upload(fp_remote: string, data: Uint8Array | string | Readable, { private: _private, print, cdn, }?: {
-        private?: boolean;
-        print?: boolean;
-        cdn?: boolean;
-    }): Promise<string>;
-    /** 获取经过签名后可访问的 url */
-    get_url(fp: string): Promise<string>;
-};

package/apps.js

@@ -1,7 +1,5 @@
 import util from 'util';
 import { call_nodejs, platform, username } from "./process.js";
-import { check } from "./utils.js";
-import { path } from "./path.js";
 export let npm = {
     bin: platform == 'win32' ? `C:/Users/${username}/AppData/Roaming/npm/node_modules/pnpm/bin/pnpm.cjs` : '/usr/bin/pnpm',
     async call(cwd, bin, args, options) {
@@ -23,76 +21,4 @@ export let npm = {
         await this.call(cwd, this.bin, args);
     },
 };
-/** 使用 tsc 编译项目
-    - fpd: 项目目录
-    - options?:
-        - tsconfig?: `'<dir>/tsconfig.json'`
-        - typecheck?: `false`  是否只进行 typecheck, (使用 call_node 执行而非 term) */
-export async function tsc(fpd, { tsconfig = './tsconfig.json', typecheck = false, } = {}) {
-    return call_nodejs(`${fpd}/node_modules/typescript/bin/tsc`, [
-        '--project', tsconfig,
-        ...typecheck ? ['--noEmit'] : []
-    ], {
-        cwd: fpd,
-        print: { command: false, code: false, stdout: true, stderr: true }
-    });
-}
-export let oss = {
-    client: null,
-    bucket: null,
-    region: null,
-    fpd_cdn: null,
-    fpd_oss: null,
-    async init({ bucket, region, fpd_cdn, fpd_oss, access_id, access_key }) {
-        if (this.client)
-            return;
-        const OSS = (await import('ali-oss')).default;
-        this.bucket = bucket;
-        this.region = region;
-        this.fpd_cdn = fpd_cdn;
-        this.fpd_oss = fpd_oss;
-        this.client = new OSS({
-            accessKeyId: access_id,
-            accessKeySecret: access_key,
-            region: this.region,
-            bucket: this.bucket,
-            secure: true
-        });
-    },
-    /** 上传文件到 oss，返回文件 url
-        - fp: 上传到 oss 的路径, 如 assets/web.latest.zip
-        - data: 文件 (Uint8Array) | 本地文件完整路径 (string) | ReadableStream
-        - options?:
-            - private?: `false` 设置为私有，需要通过 URL 签名参数访问
-            - print?: `true` 打印消息
-            - cdn?: `false` false 时返回 oss 链接，true 时返回 cdn 链接
-            - copy?: `false` 是否复制到剪贴板 */
-    async upload(fp_remote, data, { private: _private = false, print = true, cdn = false, } = {}) {
-        check(this.client, 'OSS 应该已经初始化了');
-        check(!fp_remote.startsWith('/'), 'fp 不能以 / 开头');
-        check(!fp_remote.isdir, '不能使用 oss.upload 上传文件夹，请使用 oss.upload_dir');
-        if (typeof data === 'string')
-            check(path.isAbsolute(data), 'oss.upload 传入 data 参数类型为 string 时，必须为本地文件完整路径');
-        if (data instanceof Uint8Array && !Buffer.isBuffer(data))
-            data = Buffer.from(data.buffer, data.byteOffset, data.byteLength);
-        await this.client.put(fp_remote, data);
-        let url;
-        if (_private) {
-            await this.client.putACL(fp_remote, 'private');
-            url = await this.get_url(fp_remote);
-        }
-        else
-            url = new URL(`${cdn ? this.fpd_cdn : this.fpd_oss}${fp_remote}`).toString();
-        if (print)
-            console.log(`已上传到 oss${_private ? ' (私有)' : ''}:`, url);
-        return url;
-    },
-    /** 获取经过签名后可访问的 url */
-    async get_url(fp) {
-        check(this.client, 'OSS 应该已经初始化了');
-        const url = new URL(this.client.signatureUrl(fp, { expires: /* 十年 */ 3600 * 24 * 365 * 10 }));
-        const url_ = `${this.fpd_cdn}${url.pathname.slice(1)}${url.search}`;
-        return url_;
-    }
-};
 //# sourceMappingURL=apps.js.map

package/file.d.ts

@@ -84,6 +84,7 @@ export interface FListOptions {
     absolute?: boolean;
     print?: boolean;
     stats?: boolean;
+    best_effort?: boolean;
 }
 /**
     - fpd: 文件夹完整路径 absolute path of directory
@@ -94,7 +95,7 @@ export interface FListOptions {
         - filter?: `() => true`  RegExp | (fp: string) => any
             注意当 deep = true 时被 filter 过滤掉的目录及目录中的文件不会包含在结果中
         - stats?: `false` 启用后返回 FStats 列表
-                   Returns the FStats list when enabled */
+        - best_effort?: `false` 启用后，当遇到 stat 软链接文件不存在等错误时，会返回一个 fake_time FStats 文件，而不是抛出错误 */
 export declare function flist(fpd: string): Promise<string[]>;
 export declare function flist(fpd: string, options?: FListOptions & {
     stats: true;

package/file.js

@@ -119,8 +119,25 @@ export async function fappend(fp, data, { print = true } = {}) {
             throw error;
     }
 }
+const fake_time = new Date(0);
+const fake_stats = {
+    fp: '',
+    size: 0n,
+    atimeNs: 0n,
+    mtimeNs: 0n,
+    ctimeNs: 0n,
+    birthtimeNs: 0n,
+    atimeMs: 0n,
+    mtimeMs: 0n,
+    ctimeMs: 0n,
+    birthtimeMs: 0n,
+    mtime: fake_time,
+    atime: fake_time,
+    ctime: fake_time,
+    birthtime: fake_time,
+};
 export async function flist(fpd, options = {}) {
-    const { filter, deep = false, absolute = false, print = true, stats = false } = options;
+    const { filter, deep = false, absolute = false, print = true, stats = false, best_effort = false } = options;
     check(path.isAbsolute(fpd), t("flist: 参数 fpd: '{{fpd}}' 必须是绝对路径", { fpd }));
     check(fpd.isdir, t("flist: 参数 fpd: '{{fpd}}' 必须以 / 结尾", { fpd }));
     if (!path.isAbsolute(fpd))
@@ -148,7 +165,16 @@ export async function flist(fpd, options = {}) {
         fps.push(fp);
     }
     async function _fstat(fp) {
-        let _stats = await fstat(absolute ? fp : fpd + fp);
+        let _stats;
+        try {
+            _stats = await fstat(absolute ? fp : fpd + fp);
+        }
+        catch (error) {
+            if (best_effort)
+                _stats = { ...fake_stats };
+            else
+                throw error;
+        }
         if (!absolute)
             _stats.fp = fp;
         return _stats;

package/git.d.ts

@@ -5,10 +5,10 @@ export declare class Git {
     constructor(cwd: string);
     static init(cwd: string, print?: boolean): Promise<Git>;
     static clone(repo: string, fpd: string, shallow?: boolean | string): Promise<Git>;
-    call(args?: any[], { color, print, printers, throw_code, }?: {
+    call(args?: any[], { color, print, on_stderr, throw_code, }?: {
         color?: boolean;
         print?: CallOptions['print'];
-        printers?: CallOptions['printers'];
+        on_stderr?: CallOptions['on_stderr'];
         throw_code?: CallOptions['throw_code'];
     }): Promise<import("./process.ts").CallResult<string>>;
     get_branch(): Promise<string>;

package/git.js

@@ -23,7 +23,7 @@ export class Git {
         ]);
         return git;
     }
-    async call(args = [], { color = true, print, printers, throw_code, } = {}) {
+    async call(args = [], { color = true, print, on_stderr, throw_code, } = {}) {
         return call(Git.exe, [
             ...color ? [] : [
                 '-c', 'color.status=false',
@@ -35,8 +35,8 @@ export class Git {
         ], {
             cwd: this.cwd,
             print,
-            printers,
-            throw_code
+            throw_code,
+            on_stderr
         });
     }
     async get_branch() {

package/net.browser.js

@@ -345,7 +345,7 @@ export class Remote {
         if (url)
             this.url = url;
         check(!funcs?.echo);
-        this.funcs = this.initiator ? funcs : {
+        this.funcs = {
             ...funcs,
             echo({ data }) {
                 return data;

package/net.js

@@ -530,7 +530,7 @@ export class Remote {
         if (url)
             this.url = url;
         check(!funcs?.echo);
-        this.funcs = this.initiator ? funcs : {
+        this.funcs = {
             ...funcs,
             echo({ data }) {
                 return data;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "xshell",
-    "version": "1.1.20",
+    "version": "1.1.22",
     "type": "module",
     "main": "./index.js",
     "bin": {
@@ -64,7 +64,6 @@
         "@xterm/addon-web-links": "^0.11.0",
         "@xterm/addon-webgl": "^0.18.0",
         "@xterm/xterm": "^5.5.0",
-        "ali-oss": "^6.22.0",
         "archiver": "^7.0.1",
         "chalk": "^5.4.1",
         "chardet": "^2.0.0",
@@ -90,7 +89,7 @@
         "mime-types": "^2.1.35",
         "ora": "^8.1.1",
         "react": "^19.0.0",
-        "react-i18next": "^15.2.0",
+        "react-i18next": "^15.3.0",
         "react-object-model": "^1.2.21",
         "resolve-path": "^1.4.0",
         "sass": "^1.83.0",
@@ -113,7 +112,6 @@
     },
     "devDependencies": {
         "@babel/types": "^7.26.3",
-        "@types/ali-oss": "^6.16.11",
         "@types/archiver": "^6.0.3",
         "@types/babel__traverse": "^7.20.6",
         "@types/chardet": "^0.8.3",

package/process.d.ts

@@ -1,7 +1,7 @@
 import type { InspectOptions } from 'util';
 import { type ChildProcess } from 'child_process';
 import './prototype.ts';
-import type { Encoding } from './file.ts';
+import { type Encoding } from './file.ts';
 import type { MyProxy } from './net.ts';
 export declare const sea: boolean;
 export declare const exe_nodejs: string;
@@ -18,7 +18,6 @@ export declare const print_no_command: {
         readonly stderr: true;
     };
 };
-type StdioType = 'pipe' | 'ignore' | 'inherit' | number;
 export interface FullPrintOptions {
     stdout: boolean;
     stderr: boolean;
@@ -32,13 +31,25 @@ interface BaseOptions {
     envs?: Record<string, string>;
     /** 创建子进程时添加 http_proxy, https_proxy, no_proxy 环境变量以启用代理 */
     proxy?: MyProxy | true;
-    /** 使用文件作为标准输入 */
-    fp_stdin?: string;
-    /** 使用文件作为标准输出 */
-    fp_stdout?: string;
-    /** 使用文件作为标准错误 */
-    fp_stderr?: string;
-    /** 为 true 时会设置 UV_PROCESS_WINDOWS_HIDE
+    /** 控制子进程 stdin，默认为 `false` (读空设备)，除非传入了 {@link CallOptions.input} 属性
+        - 默认值:
+            - start(): false ('ignore', 空设备)
+            - (call|launch)(): true (pipe, 作为 child.stdout 可读流)
+        - `true` 设置子进程 stdin 为 'pipe'
+        - `false` 设置子进程 stdin 为 'ignore' (空设备)
+        - `string` 设置子进程 stdin 为某个文件路径 (打开文件，将句柄设置为子进程 stdin) */
+    stdin?: boolean | string;
+    /** 控制子进程 stdout
+        - 默认值:
+            - start(): false ('ignore', 空设备)
+            - (call|launch)(): true (pipe, 作为 child.stdout 可读流)
+        - `true` 设置子进程 stdout 为 'pipe' (作为 child.stdout 可读流)
+        - `false` 设置子进程 stdout 为 'ignore' (空设备)
+        - `string` 设置子进程 stdout 某个文件路径 (打开文件，将句柄设置为子进程 stdout) */
+    stdout?: boolean | string;
+    /** 控制子进程 stderr，默认为 `stdout` 的值，用法同 {@link BaseOptions.stdout} */
+    stderr?: boolean | string;
+    /** 默认为 false，不显示窗口，会设置 UV_PROCESS_WINDOWS_HIDE
         然后设置启动进程的参数 CREATE_NO_WINDOW, 和 SW_HIDE
         D:/0/libuv/src/win/process.c
         CREATE_NO_WINDOW:
@@ -55,12 +66,6 @@ interface BaseOptions {
 export interface StartOptions extends BaseOptions {
     /** `true` 是否打印启动命令行 */
     print?: boolean;
-    /** 使用文件作为标准输入 */
-    fp_stdin?: string;
-    /** 使用文件作为标准输出 */
-    fp_stdout?: string;
-    /** 使用文件作为标准错误 */
-    fp_stderr?: string;
 }
 export declare function get_command(exe: string, args?: string[]): string;
 export interface SubProcess<TOutput extends string | Buffer = string> extends ChildProcess {
@@ -72,48 +77,44 @@ export interface SubProcess<TOutput extends string | Buffer = string> extends Ch
     args: string[];
     /** 启动命令 */
     command: string;
-    /** 调用 call 的 Promise 结果，call, launch 都有，start 创建的进程没有 */
-    presult: Promise<CallResult<TOutput>>;
+    /** 调用 call 的 Promise 结果，只有通过 launch 启动的进程有 */
+    presult?: Promise<CallResult<TOutput>>;
     /** 是否还在运行 */
     get running(): boolean;
     /** 是否已结束，等价于 !running */
     get finished(): boolean;
 }
-/** 启动独立 (detached) 的进程，不受当前 node.js 进程退出的影响，重定向 stdio 到文件或直接忽略
-    使用 windowsHide 选项避免创建命令行窗口
+/** 使用 exe 启动独立 (detached) 的进程，不受当前 node.js 进程退出的影响，可重定向 stdio 到文件（默认直接忽略）
     - exe: .exe 路径或文件名 (建议使用完整路径，跳过 path 搜索，性能更高)
     - args?: `[ ]` 参数列表
-    - options?:
-        - cwd?
+    - options?: {@link StartOptions} 继承自 {@link BaseOptions}
+        - cwd?: `'T:/'`
         - envs?: `process.env` 覆盖／添加到 process.env 的环境变量，传 null 时可以取消设置该变量
-        - encoding?: `'utf-8'` 子进程输出编码
+        - proxy?: 创建子进程时添加 http_proxy, https_proxy, no_proxy 环境变量以启用代理
         - print?: `true` 是否打印启动命令行
-        - input?: string, 启动子进程之后写入到子进程 stdin 中的内容，写完后关闭子进程 stdin (pty 不关闭)
-        - fp_stdin?: 使用文件作为标准输入，设置 stdio 中对应的值
-        - fp_stdout?: 使用文件作为标准输出，设置 stdio 中对应的值
-        - fp_stderr?: 使用文件作为标准错误，设置 stdio 中对应的值 */
+        - stdin?: 控制子进程 stdin，默认为 `false` ('ignore', 读空设备)
+            可传入 string，设置子进程 stdin 为某个文件路径 (打开文件，将句柄设置为子进程 stdin)
+        - stdout?: 控制子进程 stdout，默认为 `false` ('ignore', 写空设备)
+            可传入 string，设置子进程 stdout 某个文件路径 (打开文件，将句柄设置为子进程 stdout)
+        - stderr?: 控制子进程 stderr，默认为 `stdout` 的值，用法同 stdout
+        - window?: 默认为 false，不显示窗口，设置启动进程的参数 CREATE_NO_WINDOW, 和 SW_HIDE
+        - title?: 由创建进程的调用者设置的，用于区分、识别、记忆的可选名称 */
 export declare function start(exe: string, args?: string[], options?: StartOptions): Promise<SubProcess>;
 export interface CallOptions extends BaseOptions {
     /** `true` print 选项，支持设置细项 */
-    print?: boolean | FullPrintOptions;
+    print?: boolean | Partial<FullPrintOptions>;
     /** `true` code 不为 0 时是否抛出异常 */
     throw_code?: boolean;
-    /** `'utf-8'` 子进程输出编码 */
+    /** `'utf-8'` 子进程输出编码，不传 'binary' 则 stdout, stderr 为 string 流 */
     encoding?: 'binary' | Encoding;
-    /** `[stdin ? 'pipe' : 'ignore', 'pipe', 'pipe']` 设置为 'ignore' 时忽略 stdio 处理 */
-    stdio?: 'pipe' | 'ignore' | [StdioType, StdioType, StdioType];
-    /** `false` 子进程是否可能会读取 stdin
-        设置为 true 时会设置子进程 stdin 为 'pipe', 否则为 'ignore' */
-    stdin?: boolean;
-    /** 启动子进程之后写入到子进程 stdin 中的内容，写完后关闭子进程 stdin */
+    /** 启动子进程之后写入到子进程 stdin 中的内容，写完后就关闭子进程 stdin，通知子进程处理 */
     input?: string;
-    /** 实时处理 stdout 和 stderr 的每个 chunk，启用后子进程输出不会自动 print */
-    printers?: {
-        stdout?: (chunk: string) => void;
-        stderr?: (chunk: string) => void;
-    };
     /** 可以传入回调函数及时获取通过 start 创建的子进程，便于执行 kill、获得 pid 等操作 */
-    on_child?: (child: SubProcess) => void;
+    on_child?(child: SubProcess): void;
+    /** 实时处理 stdout 的每个 chunk，设置后子进程输出不会自动 print，且 CallResult 中 stdout 属性为 '' */
+    on_stdout?(chunk: string): void;
+    /** 实时处理 stderr 的每个 chunk，设置后子进程输出不会自动 print，且 CallResult 中 stderr 属性为 '' */
+    on_stderr?(chunk: string): void;
 }
 export interface CallResult<TOutput extends string | Buffer = string> {
     pid: number;
@@ -142,18 +143,34 @@ export declare class CallError<TOutput extends string | Buffer = string> extends
     [inspect.custom](depth: number, options: InspectOptions, inspect: Function): string;
 }
 /** 调用 exe 启动子进程，等待并获取返回结果，错误时抛出 CallError
-    - exe: .exe 路径或文件名 (建议使用路径，跳过 path 搜索，性能更高)
-    - args: `[ ]` 参数列表
-    - options?:
-        - cwd?
-        - print?: `true` print 选项，支持设置细项
+    - exe: exe 路径或文件名 (建议使用路径，跳过 path 搜索，性能更高)
+    - args?: `[ ]` 参数列表
+    - options?: {@link CallOptions} 继承自 {@link BaseOptions}
+        - cwd?: `'T:/'`
+        - print?: `true` print 选项，支持设置细项 {@link FullPrintOptions}
+            - command?: `true` 打印启动命令行
+            - code?: `true` 打印进程执行成功的消息 (进程 ... 正常结束)
+            - stdout?: `true` 打印 stdout
+            - stderr?: `true` 打印 stderr
         - throw_code?: `true` code 不为 0 时是否抛出异常
         - envs?: `process.env` 覆盖／添加到 process.env 的环境变量，传 null 时可以取消设置该变量
-        - encoding?: `'utf-8'` 子进程输出编码, 设置为 binary 时返回 stdout, stderr 类型为 Buffer; 否则是 string
-        - printers?: 实时处理 stdout 和 stderr 的每个 chunk，启用后子进程输出不会自动 print，且对应的 stdout, stderr 为空
-        - stdio?: `'pipe'` 设置为 'ignore' 时忽略 stdio 处理
+        - proxy?: 创建子进程时添加 http_proxy, https_proxy, no_proxy 环境变量以启用代理
         - input?: string, 启动子进程之后写入到子进程 stdin 中的内容，写完后关闭子进程 stdin
-        - on_child?: 可以传入回调函数及时获取通过 start 创建的子进程，便于执行 kill、获得 pid 等操作 */
+        - stdin?: 控制子进程 stdin，默认为 `false` (读空设备)，除非传入了 {@link CallOptions.input} 属性
+            - `true` 设置子进程 stdin 为 'pipe'
+            - `false` 设置子进程 stdin 为 'ignore' (空设备)
+            - `string` 设置子进程 stdin 为某个文件路径 (打开文件，将句柄设置为子进程 stdin)
+        - stdout?: 控制子进程 stdout，默认为 `true` (pipe, 作为 child.stdout 可读流)
+            - `true` 设置子进程 stdout 为 'pipe' (作为 child.stdout 可读流)
+            - `false` 设置子进程 stdout 为 'ignore' (空设备)
+            - `string` 设置子进程 stdout 某个文件路径 (打开文件，将句柄设置为子进程 stdout)
+        - stderr?: 控制子进程 stderr，用法同 {@link BaseOptions.stdout}
+        - window?: 默认为 false，不显示窗口，设置启动进程的参数 CREATE_NO_WINDOW, 和 SW_HIDE
+        - title?: 由创建进程的调用者设置的，用于区分、识别、记忆的可选名称
+        - encoding?: `'utf-8'` 子进程输出编码, 设置为 binary 时返回 stdout, stderr 类型为 Buffer; 否则是 string
+        - on_child?: 可以传入回调函数及时获取通过 spawn 创建的子进程，便于执行 kill、获得 pid 等操作
+        - on_stdout?: 实时处理 stdout 的每个 chunk，设置后子进程输出不会自动 print，且 CallResult 中 stdout 属性为 ''
+        - on_stderr?: 实时处理 stderr 的每个 chunk，设置后子进程输出不会自动 print，且 CallResult 中 stderr 属性为 '' */
 export declare function call(exe: string, args: string[], options: CallOptions & {
     encoding: 'binary';
 }): Promise<CallResult<Buffer>>;

package/process.js

@@ -2,6 +2,7 @@ import { spawn } from 'child_process';
 import os from 'os';
 import node_sea from 'node:sea';
 import "./prototype.js";
+import { fopen } from "./file.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;
@@ -15,13 +16,9 @@ export function get_command(exe, args) {
             ? ` ${args.map(arg => arg.quote_if_space()).join(' ')}`
             : '');
 }
-async function prepare_spawn(detached, exe, args, { cwd, window: _window, envs, 
+async function prepare_spawn(detached, exe, args, { cwd, window: _window = false, envs, 
 // @ts-ignore
-input, 
-// @ts-ignore
-stdin, fp_stdin, fp_stdout, fp_stderr, print = true, proxy, 
-// @ts-ignore
-stdio }) {
+input, stdin = Boolean(input), stdout = !detached, stderr = stdout, print = true, proxy, }) {
     // --- 处理 proxy, envs
     if (proxy === true) {
         const { MyProxy } = await import("./net.js");
@@ -38,53 +35,41 @@ stdio }) {
             } : {},
             ...envs
         });
-    // --- 处理 stdio
-    if (input && fp_stdin)
-        throw new Error('input 和 fp_stdin 不能同时设置');
+    // --- 处理 stdio: 将 stdio 中的 true, false, string 转换为对应的 node.js stdio 值
+    if (detached)
+        check([stdin, stdout, stderr].every(io => io !== true), '调用 start 启动 detached 进程时 stdio 不能为 true (pipe)');
     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 = [
-            // 当子进程 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) {
-            try {
-                const handle = await fopen(fp, flags);
-                opened_handles.push(handle);
-                return handle.fd;
-            }
-            catch (error) {
-                await close_all_handles();
-                throw error;
-            }
+    async function resolve_stdio(io, flags) {
+        if (io === true)
+            return 'pipe';
+        else if (typeof io === 'string') {
+            const handle = await fopen(io, flags);
+            opened_handles.push(handle);
+            return handle.fd;
         }
-        if (fp_stdin)
-            stdio[0] = await open(fp_stdin, 'r');
-        if (fp_stdout)
-            stdio[1] = await open(fp_stdout, 'w');
-        if (fp_stderr)
-            stdio[2] = fp_stderr === fp_stdout
-                ? stdio[1]
-                : await open(fp_stderr, 'w');
+        else
+            return 'ignore';
     }
-    if (detached)
-        check(stdio.every((x) => x === 'ignore' || typeof x === 'number'), '调用 start 时 stdio 只能是 fd 或者 ignore');
-    // --- 处理 stdio 结束
+    let pstdout;
+    let stdio;
+    try {
+        stdio = await Promise.all([
+            resolve_stdio(stdin, 'r'),
+            (pstdout = resolve_stdio(stdout, 'w')),
+            // 若 stderr 和 stdout 相同，则复用其 fd
+            stderr === stdout && typeof stderr === 'string'
+                ? pstdout
+                : resolve_stdio(stderr, 'w')
+        ]);
+    }
+    catch (error) {
+        await close_all_handles();
+        throw error;
+    }
+    // --- 处理 print
     if (typeof print === 'boolean')
         print = {
             command: print,
@@ -92,17 +77,23 @@ stdio }) {
             stdout: print,
             stderr: print
         };
+    print = {
+        command: print.command ?? true,
+        code: print.code ?? true,
+        stdout: stdout && (print.stdout ?? true),
+        stderr: stderr && (print.stderr ?? true)
+    };
     const command = get_command(exe, args);
     if (print.command)
         console.log(command.blue);
     return {
-        print,
+        // 已经转为了完整的 FullPrintOptions
+        print: print,
         command,
         spawn_options: {
             cwd,
             shell: false,
-            // processhacker 在 windowsHide 为 true 时不显示窗口
-            windowsHide: _window ?? Boolean(!detached || fp_stdout),
+            windowsHide: !_window,
             detached,
             stdio,
             ...envs_ ? { env: envs_ } : {}
@@ -142,19 +133,21 @@ function to_subprocess(child, { title, exe, args, command, }) {
     });
     return child;
 }
-/** 启动独立 (detached) 的进程，不受当前 node.js 进程退出的影响，重定向 stdio 到文件或直接忽略
-    使用 windowsHide 选项避免创建命令行窗口
+/** 使用 exe 启动独立 (detached) 的进程，不受当前 node.js 进程退出的影响，可重定向 stdio 到文件（默认直接忽略）
     - exe: .exe 路径或文件名 (建议使用完整路径，跳过 path 搜索，性能更高)
     - args?: `[ ]` 参数列表
-    - options?:
-        - cwd?
+    - options?: {@link StartOptions} 继承自 {@link BaseOptions}
+        - cwd?: `'T:/'`
         - envs?: `process.env` 覆盖／添加到 process.env 的环境变量，传 null 时可以取消设置该变量
-        - encoding?: `'utf-8'` 子进程输出编码
+        - proxy?: 创建子进程时添加 http_proxy, https_proxy, no_proxy 环境变量以启用代理
         - print?: `true` 是否打印启动命令行
-        - input?: string, 启动子进程之后写入到子进程 stdin 中的内容，写完后关闭子进程 stdin (pty 不关闭)
-        - fp_stdin?: 使用文件作为标准输入，设置 stdio 中对应的值
-        - fp_stdout?: 使用文件作为标准输出，设置 stdio 中对应的值
-        - fp_stderr?: 使用文件作为标准错误，设置 stdio 中对应的值 */
+        - stdin?: 控制子进程 stdin，默认为 `false` ('ignore', 读空设备)
+            可传入 string，设置子进程 stdin 为某个文件路径 (打开文件，将句柄设置为子进程 stdin)
+        - stdout?: 控制子进程 stdout，默认为 `false` ('ignore', 写空设备)
+            可传入 string，设置子进程 stdout 某个文件路径 (打开文件，将句柄设置为子进程 stdout)
+        - stderr?: 控制子进程 stderr，默认为 `stdout` 的值，用法同 stdout
+        - window?: 默认为 false，不显示窗口，设置启动进程的参数 CREATE_NO_WINDOW, 和 SW_HIDE
+        - title?: 由创建进程的调用者设置的，用于区分、识别、记忆的可选名称 */
 export async function start(exe, args = [], options = {}) {
     const { spawn_options, close_all_handles, command } = await prepare_spawn(true, exe, args, options);
     try {
@@ -205,7 +198,7 @@ export async function call(exe, args = [], options = {}) {
             await close_all_handles();
     }
     const { stdio } = spawn_options;
-    const { encoding = 'utf-8', throw_code = true, input, printers, on_child } = options;
+    const { encoding = 'utf-8', throw_code = true, input, on_stdout, on_stderr, on_child } = options;
     // 防止 child spawn 失败时 crash nodejs 进程
     child.on('error', error => {
         console.error(error);
@@ -216,39 +209,37 @@ export async function call(exe, args = [], options = {}) {
             child.stdin.end(input);
     }
     // --- 收集进程输出
+    const piped_stdout = stdio[1] === 'pipe';
+    const piped_stderr = stdio[2] === 'pipe';
     let stdouts = [];
     let stderrs = [];
-    if (stdio[1] === 'pipe') {
-        if (encoding === 'utf-8')
-            child.stdout.setEncoding('utf-8');
+    if (piped_stdout) {
+        if (encoding === 'utf-8' || encoding === 'utf-16le')
+            child.stdout.setEncoding(encoding);
         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);
-                }
-                : (chunk) => {
-                    stdouts.push(chunk);
-                });
+        child.stdout.on('data', on_stdout || (print.stdout
+            ? (chunk) => {
+                stdouts.push(chunk);
+                process.stdout.write(chunk);
+            }
+            : (chunk) => {
+                stdouts.push(chunk);
+            }));
     }
-    if (stdio[2] === 'pipe') {
-        if (encoding === 'utf-8')
-            child.stderr.setEncoding('utf-8');
+    if (piped_stderr) {
+        if (encoding === 'utf-8' || encoding === 'utf-16le')
+            child.stderr.setEncoding(encoding);
         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);
-                }
-                : (chunk) => {
-                    stderrs.push(chunk);
-                });
+        child.stderr.on('data', on_stderr || (print.stderr
+            ? (chunk) => {
+                stderrs.push(chunk);
+                process.stderr.write(chunk);
+            }
+            : (chunk) => {
+                stderrs.push(chunk);
+            }));
     }
     on_child?.(child);
     let code, signal;
@@ -279,19 +270,14 @@ export async function call(exe, args = [], options = {}) {
         child,
         print,
         [inspect.custom]() {
-            return inspect(this, {
-                omit: [
-                    'child',
-                    'message',
-                    'command',
-                    'code',
-                    'signal',
-                    'pid',
-                    'print',
-                    ...print.stdout ? ['stdout'] : [],
-                    ...print.stderr ? ['stderr'] : [],
-                ]
-            });
+            const { stdout, stderr, command, print, code, signal } = this;
+            return {
+                ...!print.command ? { command } : {},
+                ...piped_stdout && !print.stdout ? { stdout } : {},
+                ...piped_stderr && !print.stderr ? { stderr } : {},
+                ...code ? { code } : {},
+                ...signal ? { signal } : {},
+            };
         }
     };
     if (throw_code && code)
@@ -299,20 +285,15 @@ export async function call(exe, args = [], options = {}) {
     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);
-        }
+    return new Promise(resolve => {
+        const presult = call(exe, args, {
+            on_child(child) {
+                child.presult = presult;
+                resolve(child);
+            },
+            ...options,
+        });
     });
-    ps.presult = presult;
-    return ps;
 }
 /** 调用 node <js> 并等待结果
     - js: .js 路径 (相对路径根据 cwd 解析)

package/server.js

@@ -14,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, 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, colored } from "./utils.js";
 import { flist, fread, fstat } from "./file.js";
 import { exe_nodejs, sea } from "./process.js";
 // ------------ my server
@@ -36,8 +36,8 @@ export class Server {
     };
     /** sea 下最后修改时间，用于 http 资源缓存 */
     last_modified_str;
-    static js_exts = new Set(['.js', '.mjs', '.cjs']);
-    static logger_ignore_fexts = new Set(['.js', '.css', '.map', '.png', '.jpg', '.svg', '.ico', '.json', '.woff2', '.ttf', '.php']);
+    static js_exts = new Set(['js', 'mjs', 'cjs']);
+    static logger_ignore_fexts = new Set(['js', 'css', 'map', 'png', 'jpg', 'svg', 'ico', 'json', 'woff2', 'ttf', 'php']);
     static empty_body_statuses = new Set([304, 204, 205]);
     static empty_body_methods = new Set(['HEAD', 'OPTIONS']);
     app;
@@ -281,7 +281,7 @@ export class Server {
             // 时间
             `${this.log_date ? new Date().to_str() : new Date().to_time_str()}  ` +
                 // wss://
-                `${`ws${socket.encrypted ? 's' : ''}`.yellow}://` +
+                `ws${socket.encrypted ? 's' : ''}://`.yellow +
                 // host
                 host +
                 // path
@@ -386,15 +386,14 @@ export class Server {
         let { method } = request;
         if (Server.logger_ignore_fexts.has(path.fext))
             return;
-        let s = '';
         // 时间
-        s += `${this.log_date ? new Date().to_str() : new Date().to_time_str()}  `;
+        let s = `${this.log_date ? new Date().to_str() : new Date().to_time_str()}  `;
         // method
         method = method.toLowerCase();
         if (method !== 'get')
             s += `${method.yellow} `;
         // http, https, http2, websocket
-        s += `${http_version === '2.0' ? 'https'.magenta : protocol}://`;
+        s += colored(`${protocol}://`, 'magenta', http_version === '2.0');
         // host
         s += host;
         // path

package/utils.browser.d.ts

@@ -24,7 +24,8 @@ export declare function delay(milliseconds: number, { signal }?: {
 export declare class TimeoutError extends Error {
     name: "TimeoutError";
 }
-/** 在指定的时间 (milliseconds) 内运行某个任务，超时之后
+/** 在指定的时间 (milliseconds) 内运行某个任务，超时之后抛出错误或调用 on_timeout
+    - milliseconds: 限时毫秒数
     - action?: 要等待运行的任务, async function 或 promise
     - on_timeout?: 超时后调用的函数
         - 如果传入了 on_timeout 参数: 调用 on_timeout，然后 timeout 函数正常返回 null

package/utils.browser.js

@@ -76,7 +76,8 @@ export async function delay(milliseconds, { signal } = {}) {
 export class TimeoutError extends Error {
     name = 'TimeoutError';
 }
-/** 在指定的时间 (milliseconds) 内运行某个任务，超时之后
+/** 在指定的时间 (milliseconds) 内运行某个任务，超时之后抛出错误或调用 on_timeout
+    - milliseconds: 限时毫秒数
     - action?: 要等待运行的任务, async function 或 promise
     - on_timeout?: 超时后调用的函数
         - 如果传入了 on_timeout 参数: 调用 on_timeout，然后 timeout 函数正常返回 null

package/utils.d.ts

@@ -90,7 +90,8 @@ export declare function delay(milliseconds: number, options?: TimerOptions): Pro
 export declare class TimeoutError extends Error {
     name: "TimeoutError";
 }
-/** 在指定的时间 (milliseconds) 内运行某个任务，超时之后
+/** 在指定的时间 (milliseconds) 内运行某个任务，超时之后抛出错误或调用 on_timeout
+    - milliseconds: 限时毫秒数
     - action?: 要等待运行的任务, async function 或 promise
     - on_timeout?: 超时后调用的函数
         - 如果传入了 on_timeout 参数: 调用 on_timeout，然后 timeout 函数正常返回 null

package/utils.js

@@ -280,7 +280,8 @@ export async function delay(milliseconds, options) {
 export class TimeoutError extends Error {
     name = 'TimeoutError';
 }
-/** 在指定的时间 (milliseconds) 内运行某个任务，超时之后
+/** 在指定的时间 (milliseconds) 内运行某个任务，超时之后抛出错误或调用 on_timeout
+    - milliseconds: 限时毫秒数
     - action?: 要等待运行的任务, async function 或 promise
     - on_timeout?: 超时后调用的函数
         - 如果传入了 on_timeout 参数: 调用 on_timeout，然后 timeout 函数正常返回 null