xshell 1.0.60 → 1.0.62

package/Terminal.d.ts

@@ -0,0 +1,15 @@
+import 'xterm/css/xterm.css';
+import { Terminal as XTermTerminal } from 'xterm';
+import { Model } from 'react-object-model';
+import type { Remote } from './net.browser.js';
+export declare function Terminal({ font }: {
+    font: string;
+}): import("react/jsx-runtime").JSX.Element;
+declare class TerminalModel extends Model<TerminalModel> {
+    term: XTermTerminal;
+    stdio_id: number;
+    subscribe_stdio(remote: Remote): Promise<void>;
+    unsubscribe_stdio(remote: Remote): Promise<void>;
+}
+export declare let terminal: TerminalModel;
+export {};

package/Terminal.js

@@ -0,0 +1,81 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import 'xterm/css/xterm.css';
+import { useEffect, useRef } from 'react';
+import { Terminal as XTermTerminal } from 'xterm';
+import { FitAddon } from 'xterm-addon-fit';
+import { WebglAddon } from 'xterm-addon-webgl';
+import { Model } from 'react-object-model';
+import { assert, genid } from './utils.browser.js';
+export function Terminal({ font }) {
+    let rterminal = useRef();
+    useEffect(() => {
+        (async () => {
+            await document.fonts.ready;
+            let term = new XTermTerminal({
+                fontFamily: font,
+                fontSize: 16,
+                cursorStyle: 'bar',
+                disableStdin: true,
+                convertEol: true,
+                allowProposedApi: true,
+                theme: {
+                    ...myscheme,
+                    magenta: myscheme.purple,
+                    brightMagenta: myscheme.brightPurple,
+                }
+            });
+            const fit_addon = new FitAddon();
+            term.loadAddon(fit_addon);
+            term.open(rterminal.current);
+            term.loadAddon(new WebglAddon());
+            fit_addon.fit();
+            terminal.set({ term });
+        })();
+    }, []);
+    return _jsx("div", { className: 'term', ref: rterminal });
+}
+class TerminalModel extends Model {
+    term;
+    stdio_id = 0;
+    async subscribe_stdio(remote) {
+        assert(!this.stdio_id);
+        const id = this.stdio_id = genid();
+        remote.handlers.set(id, ({ data: [chunk] }) => {
+            this.term.write(chunk);
+        });
+        await remote.send({ id, func: 'subscribe_stdio' });
+    }
+    async unsubscribe_stdio(remote) {
+        let { stdio_id } = this;
+        assert(stdio_id);
+        await remote.call('unsubscribe_stdio', [stdio_id]);
+        remote.handlers.delete(stdio_id);
+        this.stdio_id = 0;
+    }
+}
+export let terminal = new TerminalModel();
+/** winterm.json */
+const myscheme = {
+    background: '#FFFFFF',
+    black: '#000000',
+    blue: '#0070C0',
+    brightBlack: '#444444',
+    brightBlue: '#0000FF',
+    brightCyan: '#008080',
+    brightGreen: '#718C00',
+    brightPurple: '#8959A8',
+    brightRed: '#DF0000',
+    brightWhite: '#AAAAAA',
+    brightYellow: '#FF81FF',
+    cursorColor: '#000000',
+    cyan: '#821717',
+    foreground: '#000000',
+    green: '#008000',
+    name: 'myscheme',
+    purple: '#800080',
+    red: '#C82829',
+    selectionBackground: '#ADD6FF',
+    white: '#888888',
+    yellow: '#EC7600'
+};
+//# sourceMappingURL=Terminal.js.map

package/file.d.ts

@@ -116,12 +116,14 @@ export declare function fdelete(fp: string, { print }?: {
     - options?:
         - print?: `true`
         - overwrite?: `true`
-    
+        - filter?: 当 fp_src 为文件夹时选择性复制里面的部分内容，和 flist 的 filter 选项一样，但只支持文件夹中第一层的文件
+        
     @example
     fcopy('D:/temp/camera/', 'D:/camera/') */
-export declare function fcopy(fp_src: string, fp_dst: string, { print, overwrite, }?: {
+export declare function fcopy(fp_src: string, fp_dst: string, { print, overwrite, filter, }?: {
     print?: boolean;
     overwrite?: boolean;
+    filter?: FListOptions['filter'];
 }): Promise<void>;
 /** 移动文件或文件夹
     相同分区 / 文件系统下使用 rename, 否则 fallback 到复制后删除源文件

package/file.js

@@ -226,22 +226,31 @@ export async function fdelete(fp, { print = true } = {}) {
     - options?:
         - print?: `true`
         - overwrite?: `true`
-    
+        - filter?: 当 fp_src 为文件夹时选择性复制里面的部分内容，和 flist 的 filter 选项一样，但只支持文件夹中第一层的文件
+        
     @example
     fcopy('D:/temp/camera/', 'D:/camera/') */
-export async function fcopy(fp_src, fp_dst, { print = true, overwrite = true, } = {}) {
+export async function fcopy(fp_src, fp_dst, { print = true, overwrite = true, filter, } = {}) {
     const { isdir } = fp_src;
     assert(isdir === fp_dst.isdir, t('fp_src 和 fp_dst 必须同为文件路径或文件夹路径'));
     assert(path.isAbsolute(fp_src) && path.isAbsolute(fp_dst), t('fp_src 和 fp_dst 必须为完整路径'));
+    if (!isdir && filter)
+        throw new Error(t('filter 选项只适用于 fp_src 为文件夹'));
     if (print)
         console.log(t('复制'), fp_src, '->', fp_dst);
     if (isdir)
-        await fsp.cp(fp_src, fp_dst, {
-            recursive: true,
-            force: overwrite,
-            errorOnExist: !overwrite,
-            mode: overwrite ? 0 : fs.constants.COPYFILE_EXCL,
-        });
+        if (filter) {
+            await fmkdir(fp_dst, { print });
+            await Promise.all((await flist(fp_src, { filter, print: false }))
+                .map(async (fname) => fcopy(fp_src + fname, fp_dst + fname, { print, overwrite })));
+        }
+        else
+            await fsp.cp(fp_src, fp_dst, {
+                recursive: true,
+                force: overwrite,
+                errorOnExist: !overwrite,
+                mode: overwrite ? 0 : fs.constants.COPYFILE_EXCL,
+            });
     else
         try {
             await fsp.copyFile(fp_src, fp_dst, overwrite ? 0 : fs.constants.COPYFILE_EXCL);
@@ -306,7 +315,7 @@ export async function frename(fp, fp_, { fpd, print = true, overwrite = true } =
     assert(path.isAbsolute(fp) && path.isAbsolute(fp_), t('fp 和 fp_ 必须是绝对路径'));
     if (print)
         console.log(t('重命名'), fp, '->', fp_);
-    if (!overwrite && fexists(fp_))
+    if (!overwrite && fexists(fp_, { print: false }))
         throw new Error(`${t('已存在')} ${fp}`);
     await fsp.rename(fp, fp_);
 }

package/i18n/dict.json

@@ -346,5 +346,20 @@
     },
     "flstat: 参数 fp: '{{fp}}' 必须是绝对路径": {
         "en": "flstat: parameter fp: '{{fp}}' must be an absolute path"
+    },
+    "filter 选项只适用于 fp_src 为文件夹": {
+        "en": "filter option only applies to fp_src for folders"
+    },
+    "已订阅 stdio": {
+        "en": "subscribed to stdio"
+    },
+    "由于 websocket 连接关闭，stdio 订阅被关闭": {
+        "en": "stdio subscription was closed due to websocket connection closed"
+    },
+    "已取消订阅 stdio": {
+        "en": "stdio unsubscribed"
+    },
+    "{{name}} 启动成功，正在监听 {{ports}} 端口": {
+        "en": "{{name}} started successfully and is listening on {{ports}} port"
     }
 }

package/i18n/scanner/index.js

@@ -18,7 +18,7 @@ const DEFAULT_CONFIG = {
     debug: false,
     input: [
         // 'src/**/*.{js,jsx,ts,tsx}',
-        '!i18n/**',
+        '!i18n/**', // Use ! to filter out files or directories
         '!node_modules/**',
         '!**/*.d.ts',
     ],
@@ -35,7 +35,7 @@ const DEFAULT_CONFIG = {
         extensions: [], // 避免在 transform 中执行原生的 parseFuncFromString
     },
     trans: {
-        extensions: [],
+        extensions: [], // 避免在 transform 中执行原生的 parseTransFromString
         fallbackKey: true,
         babylon: {
             sourceType: 'module',
@@ -74,22 +74,22 @@ const DEFAULT_CONFIG = {
         }
     },
     // 禁用 : 和 . 作为 seperator
-    keySeparator: false,
-    nsSeparator: false,
+    keySeparator: false, // char to separate keys
+    nsSeparator: false, // char to split namespace from key
     // Context Form
-    context: true,
-    contextFallback: true,
-    contextSeparator: '_',
+    context: true, // whether to add context form key
+    contextFallback: true, // whether to add a fallback key as well as the context form key
+    contextSeparator: '_', // char to split context from key
     // Plural
     // whether to add plural form key
     plural(language, ns, key, options /** Config */) {
         return language === 'en';
     },
-    pluralFallback: true,
-    pluralSeparator: '_',
+    pluralFallback: true, // whether to add a fallback key as well as the plural form key
+    pluralSeparator: '_', // char to split plural from key
     // interpolation options
     interpolation: {
-        prefix: '{{',
+        prefix: '{{', // prefix for interpolation
         suffix: '}}' // suffix for interpolation
     }
 };

package/net.js

@@ -87,7 +87,7 @@ export async function request(url, { method, queries, headers: _headers, body, t
     // --- headers, http/2 开始都用小写的 headers
     let headers = new Headers({
         'accept-language': 'zh-CN,zh;q=0.9,en-US;q=0.8,en;q=0.7,ja-JP;q=0.6,ja;q=0.5',
-        'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/117.0.0.0 Safari/537.36',
+        'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36',
         'sec-ch-ua-platform': '"Windows"',
         'sec-ch-ua-platform-version': '"15.0.0"',
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xshell",
-  "version": "1.0.60",
+  "version": "1.0.62",
   "type": "module",
   "main": "./index.js",
   "bin": {
@@ -16,7 +16,7 @@
     "interactive programming"
   ],
   "engines": {
-    "node": ">=20.6.1",
+    "node": ">=21.3.0",
     "vscode": ">=1.81.0"
   },
   "author": "ShenHongFei <shen.hongfei@outlook.com> (https://github.com/ShenHongFei)",
@@ -45,11 +45,11 @@
     ]
   },
   "dependencies": {
-    "@babel/core": "^7.23.3",
-    "@babel/parser": "^7.23.3",
-    "@babel/traverse": "^7.23.3",
+    "@babel/core": "^7.23.5",
+    "@babel/parser": "^7.23.5",
+    "@babel/traverse": "^7.23.5",
     "@koa/cors": "^4.0.0",
-    "@types/ws": "^8.5.9",
+    "@types/ws": "^8.5.10",
     "byte-size": "^8.1.1",
     "chalk": "^5.3.0",
     "chardet": "^2.0.0",
@@ -61,7 +61,7 @@
     "fetch-cookie": "^2.1.0",
     "gulp-sort": "^2.0.0",
     "hash-string": "^1.0.0",
-    "i18next": "^23.6.0",
+    "i18next": "^23.7.7",
     "i18next-scanner": "^4.4.0",
     "js-cookie": "^3.0.5",
     "koa": "^2.14.2",
@@ -71,40 +71,45 @@
     "mime-types": "^2.1.35",
     "ora": "^7.0.1",
     "react": "^18.2.0",
-    "react-i18next": "^13.3.1",
+    "react-i18next": "^13.5.0",
+    "react-object-model": "^1.2.0",
     "resolve-path": "^1.4.0",
     "strip-ansi": "^7.1.0",
     "through2": "^4.0.2",
     "tough-cookie": "^4.1.3",
     "tslib": "^2.6.2",
-    "typescript": "^5.2.2",
+    "typescript": "^5.3.2",
     "ua-parser-js": "2.0.0-alpha.2",
-    "undici": "^5.27.2",
+    "undici": "^5.28.2",
     "vinyl": "^3.0.0",
     "vinyl-fs": "^4.0.0",
-    "ws": "^8.14.2"
+    "ws": "^8.14.2",
+    "xterm": "^5.3.0",
+    "xterm-addon-fit": "^0.8.0",
+    "xterm-addon-web-links": "^0.9.0",
+    "xterm-addon-webgl": "^0.16.0"
   },
   "devDependencies": {
-    "@babel/types": "^7.23.3",
+    "@babel/types": "^7.23.5",
     "@types/babel__traverse": "^7.20.4",
     "@types/byte-size": "^8.1.2",
     "@types/chardet": "^0.8.3",
     "@types/gulp-sort": "2.0.4",
     "@types/js-cookie": "^3.0.6",
-    "@types/koa": "^2.13.11",
+    "@types/koa": "^2.13.12",
     "@types/koa-compress": "^4.0.6",
-    "@types/lodash": "^4.14.201",
+    "@types/lodash": "^4.14.202",
     "@types/mime-types": "^2.1.4",
-    "@types/node": "^20.9.0",
-    "@types/react": "^18.2.37",
+    "@types/node": "^20.10.3",
+    "@types/react": "^18.2.41",
     "@types/through2": "^2.0.41",
     "@types/tough-cookie": "^4.0.5",
     "@types/ua-parser-js": "^0.7.39",
     "@types/vinyl-fs": "^3.0.5",
-    "@types/vscode": "^1.84.1",
-    "@typescript-eslint/eslint-plugin": "^6.10.0",
-    "@typescript-eslint/parser": "^6.10.0",
-    "eslint": "^8.53.0",
+    "@types/vscode": "^1.84.2",
+    "@typescript-eslint/eslint-plugin": "^6.13.1",
+    "@typescript-eslint/parser": "^6.13.1",
+    "eslint": "^8.55.0",
     "eslint-plugin-react": "^7.33.2",
     "eslint-plugin-xlint": "^1.0.10"
   },

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

@@ -18,6 +18,7 @@ interface StartOptions {
         stdout: boolean;
         stderr: boolean;
         command: boolean;
+        /** 进程执行成功的消息 */
         code: boolean;
     };
     /** `'pipe'` 设置为 'ignore' 时忽略 stdio 处理  when 'ignore' then ignore stdio processing */

package/prototype.browser.js

@@ -309,7 +309,7 @@ Object.defineProperties(String.prototype, {
         },
         fext() {
             const index = this.lastIndexOf('.');
-            return index === -1 ? '' : this.slice(index + 1);
+            return index === -1 ? '' : this.slice(index);
         },
     }),
 });

package/repl.js

@@ -5,7 +5,6 @@ import { path } from './path.js';
 import { t } from './i18n/instance.js';
 import './prototype.js';
 import { delay, set_inspect_options } from './utils.js';
-import { Remote } from './net.js';
 set_inspect_options();
 let server;
 /** 谨慎使用，webpack 打包后可能会变成 /d:/1/mod/node_modules/xshell/ 这样的编译期路径 */
@@ -31,15 +30,14 @@ export async function start_repl() {
             // --- http server
             let { Server } = await import('./server.js');
             server = new Server({
-                port: 8421,
-                remote: new Remote({
-                    funcs: {
-                        echo({ data: [data] }) {
-                            console.log('echo:', data);
-                            return [data];
-                        },
-                    }
-                })
+                name: 'repl',
+                http_port: 8421,
+                funcs: {
+                    echo({ data: [data] }) {
+                        console.log('echo:', data);
+                        return [data];
+                    },
+                }
             });
             await server.start();
         })(),

package/server.d.ts

@@ -1,9 +1,8 @@
 /// <reference types="node" resolution-mode="require"/>
-/// <reference types="ua-parser-js" />
 /// <reference types="node" resolution-mode="require"/>
 /// <reference types="node" resolution-mode="require"/>
 import { type Server as HttpServer, type IncomingHttpHeaders } from 'http';
-import type { IncomingHttpHeaders as IncomingHttp2Headers } from 'http2';
+import { type Http2SecureServer, type IncomingHttpHeaders as IncomingHttp2Headers } from 'http2';
 import type { WebSocketServer } from 'ws';
 import type { default as Koa, Context, Next } from 'koa';
 declare module 'koa' {
@@ -16,7 +15,8 @@ declare module 'koa' {
         compress: boolean;
     }
 }
-import { type Remote, type Headers, type RequestOptions } from './net.js';
+import type { UAParser } from 'ua-parser-js';
+import { Remote, type Headers, type RequestOptions } from './net.js';
 declare module 'http' {
     interface IncomingMessage {
         body?: Buffer;
@@ -28,34 +28,50 @@ declare module 'http' {
 export declare class Server {
     /** proxy 时需要丢弃的 resposne headers */
     static drop_response_headers: Set<string>;
-    UAParser: {
-        (uastring?: string, extensions?: Record<string, unknown>): import("ua-parser-js").IResult;
-        (extensions?: Record<string, unknown>): import("ua-parser-js").IResult;
-        new (uastring?: string, extensions?: Record<string, unknown>): import("ua-parser-js").UAParserInstance;
-        new (extensions?: Record<string, unknown>): import("ua-parser-js").UAParserInstance;
-        VERSION: string;
-        BROWSER: import("ua-parser-js").BROWSER;
-        CPU: import("ua-parser-js").CPU;
-        DEVICE: import("ua-parser-js").DEVICE;
-        ENGINE: import("ua-parser-js").ENGINE;
-        OS: import("ua-parser-js").OS;
-        UAParser: any;
-    };
+    name: string;
+    UAParser: typeof UAParser;
     js_exts: Set<string>;
     app: Koa;
     handler: ReturnType<Koa['callback']>;
-    port: number;
-    server_http: HttpServer;
-    server_ws?: WebSocketServer;
+    http_port: number;
+    http2_port: number;
+    /** http2 server 证书文件夹路径，设置后才会启用 http2 server */
+    fpd_certs?: string;
+    default_hostnames?: string[];
+    http_server: HttpServer;
+    http2_server?: Http2SecureServer;
+    websocket_server?: WebSocketServer;
+    /** 设置后会启用 websocket rpc */
     remote?: Remote;
     colors: boolean;
-    constructor({ port, remote }?: {
-        port?: number;
+    /** 启用后增加 stdio 订阅相关的 remote.funcs */
+    stdio_subscribable?: boolean;
+    stdio_subscribers: (((chunk: Uint8Array | string) => Promise<void>) & {
+        id: number;
+    })[];
+    /** 原始 process.stdout.write 函数 bind 后的备份 */
+    stdout_write: Function;
+    stderr_write: Function;
+    encoder: TextEncoder;
+    constructor({ name, http_port, http2_port, fpd_certs, default_hostnames, remote, funcs, stdio_subscribable, }: {
+        name: string;
+        http_port?: number;
+        http2_port?: number;
+        fpd_certs?: string;
+        default_hostnames?: string[];
         remote?: Remote;
+        funcs?: Remote['funcs'];
+        stdio_subscribable?: boolean;
     });
     /** start http server and listen */
     start(): Promise<void>;
     stop(): void;
+    /** 可被子类重写定义错误处理逻辑 */
+    on_error(error: Error & {
+        code?: string;
+    }, ctx?: Context): void;
+    /** 可被子类重写添加额外的中间件，在 start 时被调用 */
+    init_app(app: Koa): Promise<void>;
     entry(ctx: Context, next: Next): Promise<void>;
     /** 解析 req.body to request.body
         处理 request.ip */
@@ -63,6 +79,8 @@ export declare class Server {
     _router(ctx: Context, next: Next): Promise<void>;
     /** 被子类重写以自定义处理逻辑 */
     router(ctx: Context): Promise<boolean>;
+    /** 重定向 ctx 到 url (可以是完整 url 也可以是路径)，设置 status code 为 code */
+    redirect(ctx: Context, url: string, code?: 301 | 302): void;
     logger(ctx: Context): void;
     process_ua(ctx: Context): string;
     format_ua(headers: IncomingHttpHeaders | IncomingHttp2Headers): string;

package/server.js

@@ -1,13 +1,15 @@
 import { createServer as http_create_server } from 'http';
+import { createSecureServer as http2_create_server } from 'http2';
+import { createSecureContext } from 'tls';
 import zlib from 'zlib';
 import { createReadStream } from 'fs';
 import { Readable } from 'stream';
 import util from 'util';
 // --- my libs
 import { t } from './i18n/instance.js';
-import { request as _request } from './net.js';
+import { request as _request, Remote } from './net.js';
 import { stream_to_buffer, inspect, output_width, assert } from './utils.js';
-import { fstat } from './file.js';
+import { flist, fread, fstat } from './file.js';
 // ------------ my server
 export class Server {
     /** proxy 时需要丢弃的 resposne headers */
@@ -19,20 +21,47 @@ export class Server {
         'transfer-encoding',
         'x-powered-by'
     ]);
-    UAParser = null;
+    name;
+    UAParser;
     js_exts = new Set(['.js', '.mjs', '.cjs']);
     app;
     handler;
-    port;
-    server_http;
-    server_ws;
+    http_port = 80;
+    http2_port = 443;
+    /** http2 server 证书文件夹路径，设置后才会启用 http2 server */
+    fpd_certs;
+    default_hostnames;
+    http_server;
+    http2_server;
+    websocket_server;
+    /** 设置后会启用 websocket rpc */
     remote;
     colors = util.inspect.defaultOptions.colors;
-    constructor({ port, remote } = {}) {
-        if (port !== undefined)
-            this.port = port;
+    /** 启用后增加 stdio 订阅相关的 remote.funcs */
+    stdio_subscribable;
+    stdio_subscribers;
+    /** 原始 process.stdout.write 函数 bind 后的备份 */
+    stdout_write;
+    stderr_write;
+    encoder = new TextEncoder();
+    constructor({ name, http_port, http2_port, fpd_certs, default_hostnames, remote, funcs, stdio_subscribable, }) {
+        this.name = name;
+        if (http_port !== undefined)
+            this.http_port = http_port;
+        if (http2_port !== undefined)
+            this.http2_port = http2_port;
+        if (fpd_certs)
+            this.fpd_certs = fpd_certs;
+        if (default_hostnames)
+            this.default_hostnames = default_hostnames;
         if (remote)
             this.remote = remote;
+        else if (funcs)
+            this.remote = new Remote({ funcs });
+        if (stdio_subscribable !== undefined) {
+            assert(remote || funcs);
+            this.stdio_subscribable = stdio_subscribable;
+        }
     }
     /** start http server and listen */
     async start() {
@@ -44,10 +73,7 @@ export class Server {
         const { WebSocketServer } = await import('ws');
         // --- init koa app
         let app = new Koa();
-        app.on('error', (error, ctx) => {
-            console.error(error);
-            console.log(ctx);
-        });
+        app.on('error', this.on_error.bind(this));
         app.use(this.entry.bind(this));
         app.use(KoaCompress({
             br: {
@@ -61,23 +87,48 @@ export class Server {
             threshold: 512
         }));
         app.use(KoaCors({ credentials: true }));
+        await this.init_app(app);
         app.use(this._router.bind(this));
         this.app = app;
         this.handler = this.app.callback();
-        this.server_http = http_create_server(this.handler);
+        this.http_server = http_create_server(this.handler);
+        const { fpd_certs } = this;
+        if (fpd_certs) {
+            let lazy_secure_ctxs = Object.fromEntries(await Promise.all(
+            // fpd_certs 文件夹下面的每个 .key 对应一个证书及域名
+            (await flist(fpd_certs, { print: false, filter: /\.key$/ }))
+                .map(async (fname) => {
+                const domain = fname.slice(0, -'.key'.length);
+                const [key, cert] = await Promise.all([
+                    fname,
+                    `${domain}.crt`,
+                ].map(async (fname) => fread(`${fpd_certs}${fname}`, { print: false })));
+                return [domain, { key, cert }];
+            })));
+            const default_ctx = this.default_hostnames[this.default_hostnames.find(hostname => hostname in lazy_secure_ctxs)];
+            assert(default_ctx);
+            this.http2_server = http2_create_server({
+                SNICallback(servername, callback) {
+                    let lazy_ctx = lazy_secure_ctxs[servername] || default_ctx;
+                    callback(null, lazy_ctx.ctx ??= createSecureContext(lazy_ctx));
+                },
+                allowHTTP1: true,
+            }, this.handler);
+        }
         // websocket rpc
         if (this.remote) {
-            this.server_ws = new WebSocketServer({
+            this.websocket_server = new WebSocketServer({
                 noServer: true,
                 skipUTF8Validation: true,
-                perMessageDeflate: true
+                perMessageDeflate: true,
+                maxPayload: 2 ** 30 // 1 GB
             });
-            this.server_ws.on('connection', (ws, request) => {
+            this.websocket_server.on('connection', (ws, request) => {
                 ws.addEventListener('message', ({ data }) => {
                     this.remote.handle(new Uint8Array(data), ws);
                 });
             });
-            this.server_http.on('upgrade', (request, socket, head) => {
+            this.http_server.on('upgrade', (request, socket, head) => {
                 // url 只有路径部分
                 const { url, headers, headers: { host = '' }, } = request;
                 const ip = request.socket.remoteAddress.replace(/^::ffff:/, '');
@@ -98,9 +149,9 @@ export class Server {
                     (this.colors ? url.yellow : url));
                 switch (url) {
                     case '/':
-                        this.server_ws.handleUpgrade(request, socket, head, ws => {
+                        this.websocket_server.handleUpgrade(request, socket, head, ws => {
                             ws.binaryType = 'arraybuffer';
-                            this.server_ws.emit('connection', ws, request);
+                            this.websocket_server.emit('connection', ws, request);
                         });
                         return;
                     default:
@@ -108,13 +159,95 @@ export class Server {
                         socket.destroy();
                 }
             });
+            // 将输出到 stdout, stderr 的内容 copy 一份通过 websocket 发到 web shell
+            if (this.stdio_subscribable) {
+                this.remote.funcs = {
+                    ...this.remote.funcs,
+                    subscribe_stdio: ({ id }, websocket) => {
+                        console.log(t('已订阅 stdio'));
+                        const subscriber = async (chunk) => {
+                            // send 时有可能 websocket 连接断开，抛异常，为防止循环调用 (console.error -> stdio subscriber -> throw error -> console.error)
+                            // 这里只能忽略错误
+                            try {
+                                await this.remote.send({ id, data: [typeof chunk === 'string' ? this.encoder.encode(chunk) : chunk] }, websocket);
+                            }
+                            catch { }
+                        };
+                        // 让后续可以通过 unsubscribe_stdio 取消订阅
+                        subscriber.id = id;
+                        this.stdio_subscribers.push(subscriber);
+                        websocket.addEventListener('close', () => {
+                            const length = this.stdio_subscribers.length;
+                            const stdio_subscribers_ = this.stdio_subscribers.filter(s => s !== subscriber);
+                            if (stdio_subscribers_.length !== length) {
+                                console.log(t('由于 websocket 连接关闭，stdio 订阅被关闭'));
+                                this.stdio_subscribers = stdio_subscribers_;
+                            }
+                        }, { once: true });
+                    },
+                    unsubscribe_stdio: ({ data: [id] }, websocket) => {
+                        this.stdio_subscribers = this.stdio_subscribers.filter(s => s.id !== id);
+                        console.log(t('已取消订阅 stdio'));
+                        return [];
+                    },
+                };
+                this.stdout_write = process.stdout.write.bind(process.stdout);
+                this.stderr_write = process.stderr.write.bind(process.stderr);
+                process.stdout.write = (...args) => {
+                    if (this.stdio_subscribers.length)
+                        (async () => {
+                            try {
+                                await Promise.all(this.stdio_subscribers.map(async (subscriber) => subscriber(args[0])));
+                            }
+                            catch {
+                                this.stdout_write('stdio_subscriber error\n');
+                            }
+                        })();
+                    return this.stdout_write(...args);
+                };
+                process.stderr.write = (...args) => {
+                    if (this.stdio_subscribers.length)
+                        (async () => {
+                            try {
+                                await Promise.all(this.stdio_subscribers.map(async (subscriber) => subscriber(args[0])));
+                            }
+                            catch {
+                                this.stderr_write('stderr_subscriber error\n');
+                            }
+                        })();
+                    return this.stderr_write(...args);
+                };
+            }
         }
-        await new Promise(resolve => {
-            this.server_http.listen(this.port, resolve);
-        });
+        await Promise.all([
+            new Promise(resolve => {
+                this.http_server.listen(this.http_port, resolve);
+            }),
+            fpd_certs && new Promise(resolve => {
+                this.http2_server.listen(this.http2_port, resolve);
+            }),
+        ]);
+        console.log(t('{{name}} 启动成功，正在监听 {{ports}} 端口', {
+            name: this.name,
+            ports: `${this.http_port}${fpd_certs ? `, ${this.http2_port}` : ''}`
+        }));
     }
     stop() {
-        this.server_http.close();
+        this.http_server.close();
+        if (this.http2_server)
+            this.http2_server.close();
+    }
+    /** 可被子类重写定义错误处理逻辑 */
+    on_error(error, ctx) {
+        if (error.code === 'EPIPE' || error.code === 'ECONNRESET')
+            console.log(`${error.code}:`, ctx?.request?.url);
+        else {
+            console.error(error);
+            console.log(ctx);
+        }
+    }
+    /** 可被子类重写添加额外的中间件，在 start 时被调用 */
+    async init_app(app) {
     }
     async entry(ctx, next) {
         let { response } = ctx;
@@ -170,10 +303,18 @@ export class Server {
     async router(ctx) {
         return false;
     }
+    /** 重定向 ctx 到 url (可以是完整 url 也可以是路径)，设置 status code 为 code */
+    redirect(ctx, url, code = 301) {
+        const { request: { _path } } = ctx;
+        let { response } = ctx;
+        response.redirect(url);
+        response.status = code;
+        console.log(`${code} 重定向  ${_path} -> ${url}`.yellow);
+    }
     logger(ctx) {
         const { colors } = this;
         const { request } = ctx;
-        const { query, body, path, _path, protocol, host, req: { httpVersion: http_version }, ip, } = request;
+        const { query, body, path, _path, protocol, host, req: { httpVersion: http_version }, ip, headers, } = request;
         let { method } = request;
         let s = '';
         // 时间
@@ -200,6 +341,16 @@ export class Server {
                 return colors ? path.yellow : path;
             return path;
         })();
+        // range
+        let range = headers.range;
+        if (headers.range) {
+            let [, start, end] = /(\d*)-(\d*)/.exec(range) || [];
+            if (start)
+                start = Number(start).to_fsize_str();
+            if (end)
+                end = Number(end).to_fsize_str();
+            s += ` (${start} - ${end || ''})`;
+        }
         // query
         if (Object.keys(query).length) {
             let t = inspect(query, { compact: true })
@@ -354,7 +505,7 @@ export class Server {
             - download?: `undefined` 在 response.headers 中加上 content-disposition: attachment 指示浏览器下载文件 */
     async fsend(ctx, fp, { root, absolute, download, } = {}) {
         assert(absolute || root?.isdir, t('fsend 必须传 absolute 选项或 root 文件夹'));
-        const { request } = ctx;
+        const { request, request: { method } } = ctx;
         let { response } = ctx;
         if (!absolute) {
             if (fp.startsWith(root))
@@ -384,34 +535,44 @@ export class Server {
             error.message = `fs.stat 出错: ${error.message}`;
             throw error;
         }
+        // 上面的 fstat 异步操作之后有可能 socket 已经关闭，那么这里什么都不做，直接结束吧
+        // 如果不这么做，后续 createReadStream 打开的流会赋给 response.body，但是 response.res 不再触发 finish, close 事件，
+        // 打开的流永远不会关闭，最终导致资源泄露，文件句柄一直打开
+        if (!response.socket) {
+            response.res.end();
+            return fp;
+        }
         // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Accept-Ranges
         // advertise server support of partial requests
         response.set('accept-ranges', 'bytes');
+        // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Cache-Control#up-to-date_contents_always
         if (!response.get('cache-control'))
-            response.set('cache-control', 'max-age=0, must-revalidate');
+            response.set('cache-control', 'no-cache');
+        const last_modified_str = stats.mtime.toUTCString();
         if (!response.get('last-modified'))
-            response.set('last-modified', stats.mtime.toUTCString());
+            response.set('last-modified', last_modified_str);
         if (download)
             response.set('content-disposition', `attachment; filename="${encodeURIComponent(fp.fname)}"`);
         if (!response.get('content-type')) {
             const { contentType: get_content_type } = await import('mime-types');
-            const fext = fp.fext;
-            response.set('content-type', (this.js_exts.has(fext) ? 'text/javascript; chatset=utf-8' : get_content_type(fp.fext))
+            const { fext } = fp;
+            response.set('content-type', (this.js_exts.has(fext) ? 'text/javascript; chatset=utf-8' : get_content_type(fext))
                 || 'application/octet-stream');
         }
-        if (request.fresh) {
+        const modified_since_str = request.get('if-modified-since');
+        if ((method === 'GET' || method === 'HEAD') && modified_since_str === last_modified_str) {
             response.status = 304;
             // 以上会自动设置 response.body = null
             return fp;
         }
-        if (request.headers.range)
+        const range_header = request.headers.range;
+        if (range_header)
             try {
-                const range_header = request.headers.range;
                 const range_value = /=(.*)$/.exec(range_header)[1];
                 const range = /^[\w]*?(\d*)-(\d*)$/.exec(range_value);
                 assert(stats.size <= Number.MAX_SAFE_INTEGER);
-                let start = range[1] ? parseInt(range[1]) : undefined;
-                let end = range[2] ? parseInt(range[2]) : Number(stats.size) - 1;
+                let start = range[1] ? Number(range[1]) : undefined;
+                let end = range[2] ? Number(range[2]) : Number(stats.size) - 1;
                 if (start === undefined) {
                     start = Number(stats.size) - end;
                     end = Number(stats.size) - 1;

package/utils.browser.d.ts

@@ -52,7 +52,10 @@ export declare class Lock<TResource = void> {
 export declare function pause(milliseconds?: number): Promise<void>;
 /** 字符串字典序比较 */
 export declare function strcmp(l: string, r: string): 0 | 1 | -1;
+/** 比较 1.10.02 这种版本号 */
+export declare function vercmp(l: string, r: string): number;
 export declare function get<TReturn = any>(obj: any, keypath: string): TReturn;
+export declare function global_get<TReturn = any>(keypath: string): TReturn;
 export declare function invoke<TReturn = any>(obj: any, funcpath: string, args: any[]): TReturn;
 /** 拼接 TypedArrays 生成一个完整的 Uint8Array */
 export declare function concat(arrays: ArrayBufferView[]): Uint8Array;

package/utils.browser.js

@@ -130,12 +130,29 @@ export function strcmp(l, r) {
         return -1;
     return 1;
 }
+/** 比较 1.10.02 这种版本号 */
+export function vercmp(l, r) {
+    const lparts = l.split('.').map(x => Number(x));
+    const rparts = r.split('.').map(x => Number(x));
+    assert(lparts.length === rparts.length, '传入 vercmp 的两个版本号应该格式一致');
+    for (let i = 0; i < lparts.length; i++) {
+        const l = lparts[i];
+        const r = rparts[i];
+        assert(!isNaN(l) && !isNaN(r), '传入 vercmp 的版本非法');
+        if (l !== r)
+            return l - r;
+    }
+    return 0;
+}
 export function get(obj, keypath) {
     let obj_ = obj;
     for (const key of keypath.split('.'))
         obj_ = obj_[key];
     return obj_;
 }
+export function global_get(keypath) {
+    return get(globalThis, keypath);
+}
 export function invoke(obj, funcpath, args) {
     const paths = funcpath.split('.');
     let obj_ = obj;

package/utils.d.ts

@@ -23,7 +23,10 @@ export declare function unique<T>(iterable: T[] | Iterable<T>, selector?: string
 export declare function sort_keys<T>(obj: T): T;
 /** 字符串字典序比较 */
 export declare function strcmp(l: string, r: string): 0 | 1 | -1;
+/** 比较 1.10.02 这种版本号 */
+export declare function vercmp(l: string, r: string): number;
 export declare function get<TReturn = any>(obj: any, keypath: string): TReturn;
+export declare function global_get<TReturn = any>(keypath: string): TReturn;
 export declare function invoke<TReturn = any>(obj: any, funcpath: string, args: any[]): TReturn;
 /** 拼接 TypedArrays 生成一个完整的 Uint8Array */
 export declare function concat(arrays: ArrayBufferView[]): Uint8Array;

package/utils.js

@@ -90,12 +90,29 @@ export function strcmp(l, r) {
         return -1;
     return 1;
 }
+/** 比较 1.10.02 这种版本号 */
+export function vercmp(l, r) {
+    const lparts = l.split('.').map(x => Number(x));
+    const rparts = r.split('.').map(x => Number(x));
+    assert(lparts.length === rparts.length, '传入 vercmp 的两个版本号应该格式一致');
+    for (let i = 0; i < lparts.length; i++) {
+        const l = lparts[i];
+        const r = rparts[i];
+        assert(!isNaN(l) && !isNaN(r), '传入 vercmp 的版本非法');
+        if (l !== r)
+            return l - r;
+    }
+    return 0;
+}
 export function get(obj, keypath) {
     let obj_ = obj;
     for (const key of keypath.split('.'))
         obj_ = obj_[key];
     return obj_;
 }
+export function global_get(keypath) {
+    return get(globalThis, keypath);
+}
 export function invoke(obj, funcpath, args) {
     const paths = funcpath.split('.');
     let obj_ = obj;