xshell 1.1.1 → 1.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "xshell",
-    "version": "1.1.1",
+    "version": "1.1.2",
     "type": "module",
     "main": "./index.js",
     "bin": {
@@ -57,9 +57,9 @@
         "@svgr/webpack": "^8.1.0",
         "@types/sass-loader": "^8.0.9",
         "@types/ws": "^8.5.13",
-        "@typescript-eslint/eslint-plugin": "^8.17.0",
-        "@typescript-eslint/parser": "^8.17.0",
-        "@typescript-eslint/utils": "^8.17.0",
+        "@typescript-eslint/eslint-plugin": "^8.18.0",
+        "@typescript-eslint/parser": "^8.18.0",
+        "@typescript-eslint/utils": "^8.18.0",
         "@xterm/addon-fit": "^0.10.0",
         "@xterm/addon-web-links": "^0.11.0",
         "@xterm/addon-webgl": "^0.18.0",
@@ -91,7 +91,7 @@
         "mime-types": "^2.1.35",
         "ora": "^8.1.1",
         "react": "^19.0.0",
-        "react-i18next": "^15.1.3",
+        "react-i18next": "^15.1.4",
         "react-object-model": "^1.2.20",
         "resolve-path": "^1.4.0",
         "sass": "^1.82.0",

package/process.d.ts

@@ -2,6 +2,7 @@ import { type ChildProcess } from 'child_process';
 import './prototype.ts';
 import type { Encoding } from './file.ts';
 import type { MyProxy } from './net.ts';
+export declare const sea: boolean;
 export declare const exe_nodejs: string;
 export declare const platform: NodeJS.Platform;
 export declare const username: string;

package/process.js

@@ -1,7 +1,9 @@
 import { spawn } from 'child_process';
 import os from 'os';
+import node_sea from 'node:sea';
 import "./prototype.js";
 import { inspect, DecoderStream, filter_values, check } from "./utils.js";
+export const sea = node_sea.isSea();
 export const exe_nodejs = process.execPath.fp;
 export const platform = os.platform();
 export const username = os.userInfo().username;

package/server.d.ts

@@ -27,6 +27,8 @@ export declare class Server {
     /** proxy 时需要丢弃的 resposne headers */
     static drop_response_headers: Set<string>;
     name: string;
+    /** sea 下最后修改时间，用于 http 资源缓存 */
+    last_modified_str?: string;
     UAParser: typeof UAParser;
     js_exts: Set<string>;
     empty_body_statuses: Set<number>;
@@ -115,27 +117,32 @@ export declare class Server {
         if (path.startsWith(prefix_docs)) {
             await this.try_send(
                 ctx,
-                `T:/t/docs${prefix_docs}`,
                 (path.endsWith('/') ? `${path}index.html` : path).strip_start(prefix_docs),
-                true
+                { fpd_root: `T:/t/docs${prefix_docs}` },
             )
             return
         } */
-    try_send(ctx: Context, fpd_root: string, fp: string, log_404: boolean, assets_root?: string): Promise<boolean>;
+    try_send(ctx: Context, fp: string, { fpd_root, assets_root, sea: _sea, log_404, }?: {
+        fpd_root?: string;
+        assets_root?: string;
+        sea?: boolean;
+        log_404?: boolean;
+    }): Promise<boolean>;
     /** 将 body 设置为 fp 所指文件的 ReadStream
         检查 fp 是否合法，设置对应的 content-type，支持缓存，支持分块下载
         - ctx: Koa.Context
-        - fp: 文件路径，有 root 时为相对路径或以 root 开头的绝对路径，无 root 时必须是绝对路径
+        - fp: 文件路径，有 fpd_root 时为相对路径或以 fpd_root 开头的绝对路径，无 fpd_root 时必须是绝对路径
         - options?:
-            - root?: 只能访问 root 下面的文件
+            - fpd_root?: 只能访问 fpd_root 下面的文件
             - absolute?: `false` 使用绝对路径指定发送的文件
             - download?: `undefined` 在 response.headers 中加上 content-disposition: attachment 指示浏览器下载文件
             - assets_root?: 替换模板 xxx.template.html 中 {root} 占位符 */
-    fsend(ctx: Context, fp: string, { root, absolute, download, assets_root, }?: {
-        root?: string;
+    fsend(ctx: Context, fp: string, { fpd_root, absolute, download, assets_root, sea: _sea }?: {
+        fpd_root?: string;
         absolute?: boolean;
         download?: boolean;
         assets_root?: string;
+        sea?: boolean;
     }): Promise<string>;
     /** - range: 取值为逗号分割的多个可用端口或端口区间 (不能含有空格，包含区间右值)，比如：`8321,8322,8300-8310,11000-11999
         - reverse?: `false` 在 range 内从后往前尝试 */

package/server.js

@@ -5,11 +5,13 @@ import zlib from 'zlib';
 import fs from 'fs';
 import { buffer as stream_to_buffer } from 'stream/consumers';
 import util from 'util';
+import node_sea from 'node:sea';
 // --- my libs
 import { t } from "./i18n/instance.js";
 import { request as _request, Remote } from "./net.js";
-import { inspect, output_width, check, range_to_numbers, encode, filter_keys, filter_values, consume_stream, assert } from "./utils.js";
+import { inspect, output_width, check, range_to_numbers, encode, filter_keys, filter_values, consume_stream, decode } from "./utils.js";
 import { flist, fread, fstat } from "./file.js";
+import { exe_nodejs, sea } from "./process.js";
 // ------------ my server
 export class Server {
     /** proxy 时需要丢弃的 resposne headers */
@@ -22,6 +24,8 @@ export class Server {
         'x-powered-by'
     ]);
     name;
+    /** sea 下最后修改时间，用于 http 资源缓存 */
+    last_modified_str;
     UAParser;
     js_exts = new Set(['.js', '.mjs', '.cjs']);
     empty_body_statuses = new Set([304, 204, 205]);
@@ -82,6 +86,9 @@ export class Server {
         const { default: Koa } = await import('koa');
         const { default: KoaCors } = await import('@koa/cors');
         const { default: KoaCompress } = await import('koa-compress');
+        if (sea)
+            this.last_modified_str = (await fstat(exe_nodejs))
+                .mtime.toUTCString();
         const { UAParser } = await import('ua-parser-js');
         this.UAParser = UAParser;
         // --- init koa app
@@ -534,20 +541,19 @@ export class Server {
         if (path.startsWith(prefix_docs)) {
             await this.try_send(
                 ctx,
-                `T:/t/docs${prefix_docs}`,
                 (path.endsWith('/') ? `${path}index.html` : path).strip_start(prefix_docs),
-                true
+                { fpd_root: `T:/t/docs${prefix_docs}` },
             )
             return
         } */
-    async try_send(ctx, fpd_root, fp, log_404, assets_root) {
+    async try_send(ctx, fp, { fpd_root, assets_root, sea: _sea = sea, log_404 = true, } = {}) {
         const { request: { _path, path, method }, response, } = ctx;
         if (response.body !== undefined || response.status !== 404)
             return true;
         if (method !== 'HEAD' && method !== 'GET')
             return false;
         try {
-            await this.fsend(ctx, fp, { root: fpd_root, assets_root });
+            await this.fsend(ctx, fp, { fpd_root, assets_root, sea: _sea });
             return true;
         }
         catch (error) {
@@ -565,34 +571,38 @@ export class Server {
     /** 将 body 设置为 fp 所指文件的 ReadStream
         检查 fp 是否合法，设置对应的 content-type，支持缓存，支持分块下载
         - ctx: Koa.Context
-        - fp: 文件路径，有 root 时为相对路径或以 root 开头的绝对路径，无 root 时必须是绝对路径
+        - fp: 文件路径，有 fpd_root 时为相对路径或以 fpd_root 开头的绝对路径，无 fpd_root 时必须是绝对路径
         - options?:
-            - root?: 只能访问 root 下面的文件
+            - fpd_root?: 只能访问 fpd_root 下面的文件
             - absolute?: `false` 使用绝对路径指定发送的文件
             - download?: `undefined` 在 response.headers 中加上 content-disposition: attachment 指示浏览器下载文件
             - assets_root?: 替换模板 xxx.template.html 中 {root} 占位符 */
-    async fsend(ctx, fp, { root, absolute, download, assets_root, } = {}) {
-        check(absolute || root?.isdir, t('fsend 必须传 absolute 选项或 root 文件夹'));
+    async fsend(ctx, fp, { fpd_root, absolute, download, assets_root, sea: _sea = sea } = {}) {
+        check(absolute || _sea || fpd_root?.isdir, t('fsend 必须传 absolute 选项, sea 选项, 或 fpd_root 文件夹'));
         const { request, request: { method } } = ctx;
         let { response } = ctx;
-        if (!absolute) {
-            fp = fp.strip_if_start(root).strip_if_start('/');
+        if (!absolute && !_sea) {
+            fp = fp.strip_if_start(fpd_root).strip_if_start('/');
             const { default: resolve_safely } = await import('resolve-path');
             try {
-                fp = resolve_safely(root, fp).fp;
+                fp = resolve_safely(fpd_root, fp).fp;
             }
             catch (error) {
                 error.message += `, fp: ${fp}`;
                 throw error;
             }
         }
-        // stat
+        // stats, asset
         let stats;
+        let asset;
         try {
-            stats = await fstat(fp);
+            if (_sea)
+                asset = new Uint8Array(node_sea.getRawAsset(fp));
+            else
+                stats = await fstat(fp);
         }
         catch (error) {
-            if (['ENOENT', 'ENAMETOOLONG', 'ENOTDIR'].includes(error.code)) {
+            if (_sea || ['ENOENT', 'ENAMETOOLONG', 'ENOTDIR'].includes(error.code)) {
                 error.status = 404;
                 throw error;
             }
@@ -600,6 +610,7 @@ export class Server {
             error.message = `fs.stat 出错: ${error.message}`;
             throw error;
         }
+        const size = _sea ? asset.length : Number(stats.size);
         // 上面的 fstat 异步操作之后有可能 socket 已经关闭，那么这里什么都不做，直接结束吧
         // 如果不这么做，后续 createReadStream 打开的流会赋给 response.body，但是 response.res 不再触发 finish, close 事件，
         // 打开的流永远不会关闭，最终导致资源泄露，文件句柄一直打开
@@ -613,7 +624,9 @@ export class Server {
         // 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', 'no-cache');
-        const last_modified_str = stats.mtime.toUTCString();
+        const last_modified_str = _sea
+            ? this.last_modified_str
+            : stats.mtime.toUTCString();
         if (!response.get('last-modified'))
             response.set('last-modified', last_modified_str);
         if (download)
@@ -632,8 +645,9 @@ export class Server {
         }
         if (assets_root) {
             check(fp.endsWith('.html'), '传入 assets_root 参数时 fp 应该为 .html 文件');
-            response.body = (await fread(fp, { print: false }))
-                .replaceAll('{root}', assets_root);
+            response.body = (_sea
+                ? decode(asset)
+                : (await fread(fp, { print: false }))).replaceAll('{root}', assets_root);
             return fp;
         }
         const range_header = request.headers.range;
@@ -641,28 +655,29 @@ export class Server {
             try {
                 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] ? Number(range[1]) : undefined;
-                let end = range[2] ? Number(range[2]) : Number(stats.size) - 1;
+                let end = range[2] ? Number(range[2]) : size - 1;
                 if (start === undefined) {
-                    start = Number(stats.size) - end;
-                    end = Number(stats.size) - 1;
+                    start = size - end;
+                    end = size - 1;
                 }
                 const chunksize = (end - start + 1);
                 response.status = 206;
                 response.set('content-length', String(chunksize));
-                response.set('content-range', `bytes ${start}-${end}/${stats.size}`);
-                response.body = fs.createReadStream(fp, { start, end });
+                response.set('content-range', `bytes ${start}-${end}/${size}`);
+                response.body = _sea
+                    ? asset.subarray(start, end)
+                    : fs.createReadStream(fp, { start, end });
             }
             catch {
                 response.status = 416;
-                response.set('content-length', String(stats.size));
-                response.set('content-range', `bytes */${stats.size}`);
+                response.set('content-length', String(size));
+                response.set('content-range', `bytes */${size}`);
                 response.body = fs.createReadStream(fp);
             }
         else {
-            response.set('content-length', String(stats.size));
-            response.body = fs.createReadStream(fp);
+            response.set('content-length', String(size));
+            response.body = _sea ? asset : fs.createReadStream(fp);
         }
         return fp;
     }