xshell 1.2.89 → 1.3.0

package/repl.js

@@ -41,7 +41,11 @@ export async function start_repl() {
                 name: 'repl',
                 http: true,
                 http_port: 8421,
-                funcs: {}
+                funcs: {
+                    exit() {
+                        setTimeout(stop);
+                    }
+                }
             });
             await server.start();
         })(),

package/server.d.ts

@@ -1,9 +1,9 @@
-import { type Server as HttpServer, type IncomingMessage } from 'http';
-import { type Http2SecureServer } from 'http2';
+import { type Server as HttpServer, type IncomingHttpHeaders, type IncomingMessage } from 'http';
+import { type Http2SecureServer, type IncomingHttpHeaders as IncomingHttp2Headers } from 'http2';
 import type { Duplex } from 'stream';
 import type { WebSocketServer } from 'ws';
 import { default as Koa, type Context, type Next } from 'koa';
-import { Remote, type RequestOptions, type RawResponse } from './net.ts';
+import { Remote, type RequestOptions, type RawResponse, type MessageHandler } from './net.ts';
 declare module 'http' {
     interface IncomingMessage {
         body?: Buffer;
@@ -37,6 +37,15 @@ export declare class Server {
     static logger_ignore_fexts: Set<string>;
     static empty_body_statuses: Set<number>;
     static empty_body_methods: Set<string>;
+    static windows_platform_versions: {
+        legacy: {
+            0.1: string;
+            0.2: string;
+            0.3: string;
+        };
+        /** platform_version (1 ~ 8) - 1 作为索引下标 */
+        win10: string[];
+    };
     app: Koa;
     handler: ReturnType<Koa['callback']>;
     /** 启用 http server */
@@ -52,19 +61,16 @@ export declare class Server {
     http2_server?: Http2SecureServer;
     websocket_server?: WebSocketServer;
     /** 设置后会启用 websocket rpc */
-    remote?: Remote;
+    funcs?: Record<string, MessageHandler>;
     /** 输出日志时包含日期 */
     log_date: boolean;
     /** 启用后增加 stdio 订阅相关的 remote.funcs */
     stdio_subscribable?: boolean;
-    stdio_subscribers: (((chunk: Uint8Array | string) => Promise<void>) & {
-        id: number;
-        close: () => void;
-    })[];
+    stdio_subscribers: StdioSubscriber[];
     /** 原始 process.stdout.write 函数 bind 后的备份 */
     stdout_write: Function;
     stderr_write: Function;
-    constructor({ name, print, http, http2, http_port, http2_port, fpd_certs, default_hostnames, remote, funcs, stdio_subscribable, log_date }: {
+    constructor({ name, print, http, http2, http_port, http2_port, fpd_certs, default_hostnames, funcs, stdio_subscribable, log_date }: {
         name: string;
         print?: boolean | {
             info?: boolean;
@@ -77,13 +83,13 @@ export declare class Server {
         http2_port?: number;
         fpd_certs?: string;
         default_hostnames?: string[];
-        remote?: Remote;
         funcs?: Remote['funcs'];
-        stdio_subscribable?: boolean;
+        stdio_subscribable?: true;
         log_date?: boolean;
     });
     /** start http server and listen */
     start(): Promise<void>;
+    try_write_stdio_subscribers(chunk: string | Uint8Array): void;
     stop(): void;
     /** 可被子类重写定义错误处理逻辑 */
     on_error(error: Error & {
@@ -105,6 +111,9 @@ export declare class Server {
         - code: 301 (永久重定向) | 302 (临时重定向) | 307 (非 GET 请求保持原有方法和 body 的临时重定向) */
     redirect(ctx: Context, url: string, code: 301 | 302 | 307): true;
     logger(ctx: Context): void;
+    /** model? platform platform_version / mobile browser  */
+    get_client_info(headers: IncomingHttpHeaders | IncomingHttp2Headers): string;
+    get_client_platform_and_version(platform: string, version: string): any;
     /** 转发请求到其他 http 服务，实现网关的功能
         - ctx
         - path_url: 只含 host, path, 不含 queries 的 url, 如 http://localhost:8080/api/get-user
@@ -156,6 +165,11 @@ export declare class Server {
         - reverse?: `false` 在 range 内从后往前尝试 */
     static get_available_port(range: string, reverse?: boolean): Promise<number>;
 }
+interface StdioSubscriber {
+    remote: Remote;
+    id: number;
+    close(): void;
+}
 export interface ServerRequestOptions {
     headers?: Record<string, string | null>;
     queries?: Record<string, string>;
@@ -165,3 +179,4 @@ export interface ServerRequestOptions {
     proxy?: RequestOptions['proxy'];
 }
 export declare const text_plain: "text/plain; charset=utf-8";
+export {};

package/server.js

@@ -39,6 +39,24 @@ export class Server {
     static logger_ignore_fexts = new Set(['js', 'css', 'wasm', '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']);
+    static windows_platform_versions = {
+        legacy: {
+            0.1: 'win7',
+            0.2: 'win8',
+            0.3: 'win8.1'
+        },
+        /** platform_version (1 ~ 8) - 1 作为索引下标 */
+        win10: [
+            'win10 1507',
+            'win10 1511',
+            'win10 1607',
+            'win10 1703',
+            'win10 1709',
+            'win10 1803',
+            'win10 1809',
+            'win10 1909',
+        ]
+    };
     app;
     handler;
     /** 启用 http server */
@@ -54,7 +72,7 @@ export class Server {
     http2_server;
     websocket_server;
     /** 设置后会启用 websocket rpc */
-    remote;
+    funcs;
     /** 输出日志时包含日期 */
     log_date = false;
     /** 启用后增加 stdio 订阅相关的 remote.funcs */
@@ -63,7 +81,7 @@ export class Server {
     /** 原始 process.stdout.write 函数 bind 后的备份 */
     stdout_write;
     stderr_write;
-    constructor({ name, print, http, http2, http_port, http2_port, fpd_certs, default_hostnames, remote, funcs, stdio_subscribable, log_date }) {
+    constructor({ name, print, http, http2, http_port, http2_port, fpd_certs, default_hostnames, funcs, stdio_subscribable, log_date }) {
         this.name = name;
         if (print !== undefined) {
             if (typeof print === 'boolean')
@@ -85,12 +103,10 @@ export class Server {
             this.default_hostnames = default_hostnames;
         if (log_date !== undefined)
             this.log_date = log_date;
-        if (remote)
-            this.remote = remote;
-        else if (funcs)
-            this.remote = new Remote({ funcs, print: this.print.errors });
-        if (stdio_subscribable !== undefined) {
-            check(remote || funcs);
+        if (funcs)
+            this.funcs = funcs;
+        if (stdio_subscribable) {
+            check(funcs);
             this.stdio_subscribable = stdio_subscribable;
         }
     }
@@ -122,7 +138,7 @@ export class Server {
         app.use(this._router.bind(this));
         this.app = app;
         this.handler = this.app.callback();
-        this.http_server = http_create_server(this.handler);
+        this.http_server = http_create_server({ optimizeEmptyRequests: true }, this.handler);
         const { http, http2 } = this;
         if (http2) {
             const { fpd_certs } = this;
@@ -153,7 +169,7 @@ export class Server {
             }, this.handler);
         }
         // websocket rpc
-        if (this.remote) {
+        if (this.funcs) {
             const { WebSocketServer } = await import('ws');
             this.websocket_server = new WebSocketServer({
                 noServer: true,
@@ -162,78 +178,51 @@ export class Server {
                 allowSynchronousEvents: true,
                 maxPayload: 2 ** 30 // 1 GB
             });
-            this.websocket_server.on('connection', (ws, request) => {
-                ws.addEventListener('message', ({ data }) => {
-                    this.remote.handle(new Uint8Array(data), ws);
-                });
+            this.websocket_server.on('connection', (websocket, request) => {
+                new Remote({ websocket, funcs: this.funcs });
             });
             const on_upgrade = this.on_upgrade.bind(this);
             this.http_server.on('upgrade', on_upgrade);
             this.http2_server?.on('upgrade', on_upgrade);
             // 将输出到 stdout, stderr 的内容 copy 一份通过 websocket 发到 web shell
             if (this.stdio_subscribable) {
-                this.remote.funcs = {
-                    ...this.remote.funcs,
-                    subscribe_stdio: ({ id }, websocket) => {
-                        const subscriber = async (chunk) => {
-                            // send 时有可能 websocket 连接断开，抛异常，为防止循环调用 (console.error -> stdio subscriber -> throw error -> console.error)
-                            // 这里只能忽略错误
-                            try {
-                                await this.remote.send({
-                                    id,
-                                    data: typeof chunk === 'string' ? encode(chunk) : chunk
-                                }, websocket);
-                            }
-                            catch { }
-                        };
-                        // 让后续可以通过 unsubscribe_stdio 取消订阅
-                        subscriber.id = id;
-                        const close = subscriber.close = () => {
-                            const length = this.stdio_subscribers.length;
-                            const stdio_subscribers_ = this.stdio_subscribers.filter(s => s !== subscriber);
-                            if (stdio_subscribers_.length !== length)
+                this.funcs = {
+                    ...this.funcs,
+                    subscribe_stdio: ({ id }, remote) => {
+                        let websocket = remote.lwebsocket.resource;
+                        const close = () => {
+                            const stdio_subscribers_ = this.stdio_subscribers.filter(s => s.remote !== remote);
+                            if (stdio_subscribers_.length !== this.stdio_subscribers.length)
                                 this.stdio_subscribers = stdio_subscribers_;
                         };
-                        this.stdio_subscribers.push(subscriber);
+                        this.stdio_subscribers.push({
+                            remote,
+                            id,
+                            close
+                        });
+                        websocket.addEventListener('error', close, { once: true });
                         websocket.addEventListener('close', close, { once: true });
                     },
                     /** 主动取消订阅，需要清理 stdio listener, websocket close lisener */
-                    unsubscribe_stdio: ({ data: [id] }, websocket) => {
+                    unsubscribe_stdio: (message, remote) => {
+                        let websocket = remote.lwebsocket.resource;
                         this.stdio_subscribers = this.stdio_subscribers.filter(s => {
-                            if (s.id === id) {
-                                websocket.removeEventListener('close', s.close);
-                                return false;
-                            }
-                            else
+                            if (s.remote !== remote)
                                 return true;
+                            websocket.removeEventListener('error', s.close);
+                            websocket.removeEventListener('close', s.close);
+                            return false;
                         });
-                        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');
-                            }
-                        })();
+                    this.try_write_stdio_subscribers(args[0]);
                     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');
-                            }
-                        })();
+                    this.try_write_stdio_subscribers(args[0]);
                     return this.stderr_write(...args);
                 };
             }
@@ -256,6 +245,17 @@ export class Server {
                 ].join(', ')
             }));
     }
+    try_write_stdio_subscribers(chunk) {
+        if (!this.stdio_subscribers.length)
+            return;
+        for (let i = 0; i < this.stdio_subscribers.length; ++i) {
+            let { remote, id } = this.stdio_subscribers[i];
+            remote.try_send({
+                id,
+                data: typeof chunk === 'string' ? encode(chunk) : chunk
+            });
+        }
+    }
     stop() {
         this.http_server.close();
         if (this.http2_server)
@@ -290,15 +290,19 @@ export class Server {
             s = s.pad(url_width);
             // ip
             s += `  <-  ${request.socket.remoteAddress.strip_if_start('::ffff:')}`;
+            // 客户端信息
+            const client_info = this.get_client_info(headers);
+            if (client_info)
+                s += `／${client_info}`;
             console.log(s);
         }
         switch (url) {
             case '/':
-                this.websocket_server.handleUpgrade(request, socket, head, ws => {
-                    ws.binaryType = 'arraybuffer';
-                    this.websocket_server.emit('connection', ws, request);
+                this.websocket_server.handleUpgrade(request, socket, head, websocket => {
+                    websocket.binaryType = 'arraybuffer';
+                    this.websocket_server.emit('connection', websocket, request);
                 });
-                return;
+                break;
             default:
                 if (this.print.logs)
                     console.log(`未知路径的 upgrade 请求: ${url}`.red);
@@ -426,12 +430,146 @@ export class Server {
         s = s.pad(url_width);
         // ip
         s += `  <-  ${ip}`;
+        // 客户端信息
+        const client_info = this.get_client_info(headers);
+        if (client_info)
+            s += `／${client_info}`;
         // body
         if (body)
             s += '\n' + inspect(body);
         // 打印日志
         console.log(s);
     }
+    /** model? platform platform_version / mobile browser  */
+    get_client_info(headers) {
+        const { 'user-agent': user_agent, 'sec-ch-ua': ua, 'sec-ch-ua-mobile': mobile, 'sec-ch-ua-model': _model, 'sec-ch-ua-platform': _platform, 'sec-ch-ua-platform-version': _platform_version } = headers;
+        // --- client hints
+        let model = _model?.slice(1, -1).toLowerCase();
+        if (model === '22127rk46c')
+            model = 'redmi k60 pro';
+        else if (model === '23013rk75c')
+            model = 'redmi k60';
+        else if (model === '24129pn74c')
+            model = 'xiaomi 15';
+        const ch_platform = [
+            model,
+            mobile === '?1' ? 'mobile' : '',
+            this.get_client_platform_and_version(_platform?.slice(1, -1).toLowerCase(), _platform_version?.slice(1, -1))
+        ].filter(Boolean).join(' ');
+        let ch_browser;
+        if (ua) {
+            const items = ua.toLowerCase().split(',');
+            const i_not_a_brand = items.findIndex(item => item.includes('no') && item.includes('brand'));
+            let browsers = [];
+            for (let i = 0; i < items.length; ++i) {
+                const item = items[i];
+                if (i === i_not_a_brand ||
+                    // 有除了 chromium 的其他浏览器，那么这个是垃圾
+                    item.includes('"chromium"') && items.length > 2 && i_not_a_brand !== -1)
+                    continue;
+                const matches = /"(.*)";v="(.*)"/.exec(item);
+                if (!matches) {
+                    console.log('奇怪的 ua item:', item);
+                    continue;
+                }
+                let [, name, version] = matches;
+                if (name === 'google chrome')
+                    name = 'chrome';
+                else if (name === 'microsoft edge')
+                    name = 'edge';
+                else if (name === 'android webview' && ch_platform.includes('android'))
+                    name = 'webview';
+                browsers.push(`${name} ${version}`);
+            }
+            ch_browser = browsers.join(' ');
+        }
+        // --- user-agent
+        let ua_platform;
+        let ua_browser;
+        if (user_agent) {
+            // 按照空格（非括号内, 非后面跟 (, 非 / 前） 划分多个部分
+            let parts = [];
+            let i = 0, j = 0, in_parenthesis = false;
+            for (let slash = false; i < user_agent.length; ++i) {
+                const c = user_agent[i];
+                if (c === ')' && in_parenthesis) {
+                    in_parenthesis = false;
+                    continue;
+                }
+                if (c === '/') {
+                    slash = true;
+                    continue;
+                }
+                if (c === ' ') {
+                    if (user_agent[i + 1] === '(') {
+                        in_parenthesis = true;
+                        continue;
+                    }
+                    if (!in_parenthesis && slash) {
+                        parts.push(user_agent.slice(j, i));
+                        j = i + 1;
+                        continue;
+                    }
+                }
+            }
+            const remaining = user_agent.slice(j, i);
+            if (remaining)
+                parts.push(remaining);
+            let has_mozilla = false;
+            const part0 = parts[0];
+            if (part0 && part0.startsWith('Mozilla/5.0 (') && part0.endsWith(')')) {
+                // 只取括号中间的
+                ua_platform = part0.slice(13, -1).toLowerCase()
+                    .replace('22127rk46c', 'redmi k60 pro')
+                    .replace('23013rk75c', 'redmi k60')
+                    .replace('24129pn74c', 'xiaomi 15')
+                    .replace('macintosh', 'mac')
+                    .replace('linux; android', 'android')
+                    .replace(' build/tkq1.220905.001', '');
+                // 没有多余的信息，屏蔽
+                if (ua_platform === 'windows nt 10.0; win64; x64' && ch_platform.includes('win1'))
+                    ua_platform = '';
+                if (ch_platform && ua_platform)
+                    ua_platform = ua_platform.bracket();
+                has_mozilla = true;
+            }
+            const has_chrome = parts.find(part => part.includes('Chrome'));
+            let parts_ = [];
+            for (let i = has_mozilla ? 1 : 0; i < parts.length; ++i) {
+                const part = parts[i];
+                if ((part.startsWith('AppleWebKit/') && part.endsWith(' (KHTML, like Gecko)')) ||
+                    (part.includes('Safari/') && (has_chrome || i !== parts.length - 1)) ||
+                    (part.startsWith('Chrome/') && ch_browser && (ch_browser.includes('chrome ') || ch_browser.includes('webview ')))) // 垃圾
+                    continue;
+                parts_.push(part);
+            }
+            ua_browser = parts_.join(' ').toLowerCase();
+            if (!ua_browser.includes('://'))
+                ua_browser.replaceAll('/', ' ');
+            if (ch_browser && ua_browser)
+                ua_browser = ua_browser.bracket();
+        }
+        return [
+            [ch_platform, ua_platform].filter(Boolean).join(' '),
+            [ch_browser, ua_browser].filter(Boolean).join(' ')
+        ].filter(Boolean).join('／');
+    }
+    get_client_platform_and_version(platform, version) {
+        if (platform === 'windows' && version) {
+            const v = Number(version.slice_to('.', { optional: true }));
+            if (v === 19)
+                return 'win11 24h2';
+            else if (v > 13)
+                return `win11 (${v})`;
+            else if (v === 10)
+                return 'win10 21h2';
+            else if (v >= 1)
+                return Server.windows_platform_versions.win10[v - 1];
+            else
+                return Server.windows_platform_versions.legacy[version] || `win ${version}?`;
+        }
+        return [platform, version?.strip_if_end('.0.0')].filter(Boolean).join(' ');
+    }
     /** 转发请求到其他 http 服务，实现网关的功能
         - ctx
         - path_url: 只含 host, path, 不含 queries 的 url, 如 http://localhost:8080/api/get-user

package/utils.browser.d.ts

@@ -18,4 +18,4 @@ export declare function to_option(value: string): {
 };
 export declare function download_url(name: string, url: string): void;
 export declare function download(name: string, data: string | Uint8Array, mime_type?: string): void;
-export declare function load_script(url: string): Promise<unknown>;
+export declare function load_script(url: string, type?: HTMLScriptElement['type']): Promise<Event>;

package/utils.browser.js

@@ -41,13 +41,15 @@ export function download_url(name, url) {
 export function download(name, data, mime_type) {
     download_url(name, URL.createObjectURL(new Blob([data], { type: mime_type })));
 }
-export async function load_script(url) {
+export async function load_script(url, type) {
     return new Promise((resolve, reject) => {
         let $script = document.createElement('script');
         $script.src = url;
         $script.async = true;
         $script.onload = resolve;
         $script.onerror = reject;
+        if (type)
+            $script.type = type;
         document.head.appendChild($script);
     });
 }

package/utils.common.d.ts

@@ -24,7 +24,7 @@ export declare function strcmp(l: string, r: string): 0 | 1 | -1;
 export declare function sort_keys<TObj>(obj: TObj): TObj;
 /** 比较 1.10.02 这种版本号
     - l, r: 两个版本号字符串
-    - loose?: 宽松模式，允许两个版本号格式（位数）不一致 */
+    - loose?: `false` 宽松模式，允许两个版本号格式（位数）不一致 */
 export declare function vercmp(l: string, r: string, loose?: boolean): number;
 /** 将 keys, values 数组按对应的顺序组合成一个对象 */
 export declare function zip_object<TValue>(keys: (string | number)[], values: TValue[]): Record<string, TValue>;
@@ -67,20 +67,20 @@ export declare function buffer_equals(left: Uint8Array, right: Uint8Array | stri
     - milliseconds: 限时毫秒数
     - action?: 要等待运行的任务, async function 或 promise
     - on_timeout?: 超时后调用的函数
-        - 如果传入了 on_timeout 参数: 调用 on_timeout，然后 timeout 函数正常返回 null
-        - 如果没传入 on_timeout 参数: 抛出 TimeoutError
-    - print?: 打印已超时任务的错误 */
-export declare function timeout<TReturn>(milliseconds: number, action: Promise<TReturn> | (() => Promise<TReturn>), on_timeout?: () => void | Promise<void>, print?: boolean): Promise<TReturn>;
+        - 若传: 调用 on_timeout，参数为 TimeoutError，然后 timeout 函数正常返回 null
+        - 若不传: 抛出 TimeoutError
+    - print?: `true` 打印已超时任务的错误 */
+export declare function timeout<TReturn>(milliseconds: number, action: Promise<TReturn> | (() => Promise<TReturn>), on_timeout?: (error: TimeoutError) => void | Promise<void>, print?: boolean): Promise<TReturn>;
 /** 轮询尝试 action 共 times 次，每次间隔 duration
     action 返回 trusy 值时认为成功，返回 action 的结果
     如果次数用尽仍然失败，返回 null */
 export declare function poll<TResult>(duration: number, times: number, action: (breaker: () => void) => Promise<TResult>): Promise<TResult>;
 /** 模糊过滤字符串列表或对象列表，常用于根据用户输入补全或搜索过滤
-    如果有完全匹配的，只返回那一项的数组
+    如果有完全匹配关键词的，只返回完全匹配关键词的候选项
     - query: 查询字符串，要求为全小写
-    - list: 要过滤的列表
-    - list_lower?: 要过滤的列表对应的全小写字符串列表形式，传入时可复用缓存，加快搜索速度 */
-export declare function fuzzyfilter<TItem = string>(query: string, list: TItem[], mapper?: keyof TItem | Mapper<TItem>, list_lower?: string[], single_char_startswith?: boolean): TItem[];
+    - items: TItem[], 要过滤的列表
+    - keywords: string[][] 每个 item 对应一个全小写字符串的关键词数组，用于实际筛选匹配 */
+export declare function fuzzyfilter<TItem>(query: string, items: TItem[], keywords: string[][], single_char_startswith?: boolean): TItem[];
 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;
@@ -164,3 +164,5 @@ export declare function throttle(duration: number, func: Function, delay_first?:
 export declare function debounce(duration: number, func: Function): (this: any, ...args: any[]) => void;
 export declare function tomorrow(date?: Date | string | number): Date;
 export declare function to_csv_field(str: string): string;
+/** 设置 error.message 同时更新 error.stack */
+export declare function set_error_message(error: Error, message: string): Error;