xshell 1.0.61 → 1.0.62

package/i18n/dict.json

@@ -349,5 +349,17 @@
     },
     "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/package.json

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

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 */

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,24 +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,
                 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:/, '');
@@ -99,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:
@@ -109,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;