xshell 1.0.65 → 1.0.67

package/Terminal.d.ts

@@ -1,5 +1,6 @@
 import 'xterm/css/xterm.css';
 import { Terminal as XTermTerminal } from 'xterm';
+import { FitAddon } from 'xterm-addon-fit';
 import { Model } from 'react-object-model';
 import type { Remote } from './net.browser.js';
 export declare function Terminal({ font }: {
@@ -7,7 +8,9 @@ export declare function Terminal({ font }: {
 }): import("react/jsx-runtime").JSX.Element;
 declare class TerminalModel extends Model<TerminalModel> {
     term: XTermTerminal;
+    fit_addon: FitAddon;
     stdio_id: number;
+    fit(): void;
     subscribe_stdio(remote: Remote): Promise<void>;
     unsubscribe_stdio(remote: Remote): Promise<void>;
 }

package/Terminal.js

@@ -29,14 +29,18 @@ export function Terminal({ font }) {
             term.open(rterminal.current);
             term.loadAddon(new WebglAddon());
             fit_addon.fit();
-            terminal.set({ term });
+            terminal.set({ term, fit_addon });
         })();
     }, []);
     return _jsx("div", { className: 'term', ref: rterminal });
 }
 class TerminalModel extends Model {
     term;
+    fit_addon;
     stdio_id = 0;
+    fit() {
+        this.fit_addon?.fit();
+    }
     async subscribe_stdio(remote) {
         assert(!this.stdio_id);
         const id = this.stdio_id = genid();

package/apps.d.ts

@@ -0,0 +1,54 @@
+/// <reference types="node" resolution-mode="require"/>
+import type { Readable } from 'stream';
+import type OSS from 'ali-oss';
+import { type CallOptions } from './process.js';
+export declare let npm: {
+    bin: string;
+    call(cwd: string, bin: string, args: string[], options?: CallOptions): Promise<import("./process.js").CallResult<string>>;
+    /** node.exe E:/sdk/nodejs/node_modules/corepack/dist/pnpm.js install
+        - cwd?: `fpd_root`
+        - pkgs?: `[ ]` */
+    install(cwd?: string, pkgs?: string[], { save_dev, save_peer, legacy, force, term, inspect, break: _break, }?: {
+        save_dev?: boolean;
+        save_peer?: boolean;
+        legacy?: boolean;
+        force?: boolean;
+        term?: boolean;
+        inspect?: boolean;
+        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.js").CallResult<string>>;
+export declare let oss: {
+    client: OSS;
+    bucket: string;
+    region: string;
+    root: string;
+    init({ bucket, region, root, access_id, access_key }: {
+        bucket: string;
+        region: string;
+        root: 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` 打印消息 */
+    upload(fp: string, data: Uint8Array | string | Readable, { private: _private, print, }?: {
+        private?: boolean;
+        print?: boolean;
+    }): Promise<string>;
+    /** 获取经过签名后可访问的 url */
+    get_url(fp: string): Promise<string>;
+};

package/apps.js

@@ -0,0 +1,93 @@
+import util from 'util';
+import { call_nodejs, exe_nodejs, platform } from './process.js';
+import { assert } from './utils.js';
+import { path } from './path.js';
+export let npm = {
+    bin: `${platform === 'win32' ? exe_nodejs.fdir : '/usr/lib/'}node_modules/corepack/dist/pnpm.js`,
+    async call(cwd, bin, args, options) {
+        return call_nodejs(bin, args, { cwd, ...options });
+    },
+    /** node.exe E:/sdk/nodejs/node_modules/corepack/dist/pnpm.js install
+        - cwd?: `fpd_root`
+        - pkgs?: `[ ]` */
+    async install(cwd, pkgs = [], { save_dev = false, save_peer = false, legacy = false, force = false, term = false, inspect = false, break: _break = false, } = {}) {
+        const args = [
+            'install',
+            ...util.inspect.defaultOptions.colors ? ['--color'] : [],
+            ...legacy ? ['--legacy-peer-deps'] : [],
+            ...force ? ['--force'] : [],
+            ...save_dev ? ['--save-dev'] : [],
+            ...save_peer ? ['--save-peer'] : [],
+            ...pkgs || []
+        ];
+        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,
+    root: null,
+    async init({ bucket, region, root, access_id, access_key }) {
+        if (this.client)
+            return;
+        const OSS = (await import('ali-oss')).default;
+        this.bucket = bucket;
+        this.region = region;
+        this.root = root;
+        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` 打印消息 */
+    async upload(fp, data, { private: _private = false, print = true, } = {}) {
+        assert(this.client, 'OSS 应该已经初始化了');
+        assert(!fp.isdir, '不能使用 oss.upload 上传文件夹，请使用 oss.upload_dir');
+        if (typeof data === 'string')
+            assert(data[1] === ':' && 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, data);
+        let url;
+        if (_private) {
+            await this.client.putACL(fp, 'private');
+            url = await this.get_url(fp);
+        }
+        else
+            url = new URL(this.root + fp).toString();
+        if (print)
+            console.log(`已上传到 OSS${_private ? ' (私有)' : ''}:`, url);
+        return url;
+    },
+    /** 获取经过签名后可访问的 url */
+    async get_url(fp) {
+        assert(this.client, 'OSS 应该已经初始化了');
+        const url = new URL(this.client.signatureUrl(fp, { expires: /* 十年 */ 3600 * 24 * 365 * 10 }));
+        const url_ = `${this.root}${url.pathname.slice(1)}${url.search}`;
+        return url_;
+    }
+};
+//# sourceMappingURL=apps.js.map

package/file.d.ts

@@ -171,6 +171,30 @@ export declare function flink(fp_real: string, fp_link: string, { junction, prin
     junction?: boolean;
     print?: boolean;
 }): Promise<void>;
+export interface ZipOptions {
+    dirname?: string;
+    print?: {
+        info: boolean;
+        files: boolean;
+    };
+}
+/** 将文件夹压缩为 zip
+    返回 fp_zip 或压缩包数据
+    - data:
+        - 被压缩文件夹路径 (fpd_src: string) 或
+        - 文件索引对象 (entries: Record<压缩后相对路径, 原文件绝对路径 (string) | 数据 (Uint8Array)>)
+    - fp_zip?:
+        - 传压缩包完整路径时压缩到文件, 函数返回值为 Promise<zip 路径>
+        - 传 undefined 时压缩到内存, 函数返回值为 Promise<zip Uint8Array>
+    - options?:
+        - dirname?: `fpd_src.fname` 传入 fpd_src 才生效，修改 zip 中顶层的文件夹的名字（需要以 / 结尾），如 'web/', 为空字符串时去掉顶层文件夹，不要多一个文件夹层级 (flat)
+        - print?:
+            - info?: `true` 开始压缩、压缩完成
+            - files?: `true` 打印压缩文件列表 */
+export declare function fzip(entries: Record<string, string | Uint8Array>, fp_zip?: undefined, options?: ZipOptions): Promise<Uint8Array>;
+export declare function fzip(entries: Record<string, string | Uint8Array>, fp_zip: string, options?: ZipOptions): Promise<string>;
+export declare function fzip(fpd_src: string, fp_zip?: undefined, options?: ZipOptions): Promise<Uint8Array>;
+export declare function fzip(fpd_src: string, fp_zip: string, options?: ZipOptions): Promise<string>;
 export declare let fwatchers: Record<string, fs.FSWatcher>;
 /** 跟踪文本文件追加的内容，类似 tail -f */
 export declare function ftail(fp: string, handler: (lines: string[]) => void | Promise<void>, { print }?: {

package/file.js

@@ -3,7 +3,7 @@ import { isUint8Array } from 'util/types';
 import { path } from './path.js';
 import { t } from './i18n/instance.js';
 import { to_json } from './prototype.js';
-import { assert, Lock } from './utils.js';
+import { assert, Lock, WritableMemoryStream } from './utils.js';
 export { fsp };
 export const encodings = ['utf-8', 'gb18030', 'shift-jis', 'utf-16le'];
 /** fp 所指向的 文件/ 文件夹 是否存在
@@ -367,6 +367,64 @@ export async function flink(fp_real, fp_link, { junction = false, print = true }
     else
         fsp.symlink(fp_real, fp_link, is_fpd_real ? 'dir' : 'file');
 }
+export async function fzip(data, fp_zip, { dirname, print = { files: true, info: true } } = {}) {
+    let entries;
+    let fpd_src;
+    if (typeof data === 'string') {
+        if (!path.isAbsolute(data) || !data.isdir)
+            throw new Error('fpd_src 必须是绝对路径且以 / 结尾');
+        fpd_src = data;
+        if (dirname === undefined)
+            dirname = fpd_src.fname;
+        if (!dirname.isdir)
+            throw new Error('dirname 需要以 / 结尾');
+        entries = Object.fromEntries((await flist(fpd_src, { print: false }))
+            .map(fp => ([dirname + fp, fpd_src + fp])));
+    }
+    else
+        entries = data;
+    if (print.info)
+        console.log(`开始压缩${fpd_src ? ` ${fpd_src}` : '文件索引'} -> ${fp_zip ? `${fp_zip}/${dirname}` : '内存'}`);
+    const { default: archiver } = await import('archiver');
+    let archive = archiver('zip', { zlib: { chunkSize: 16 * 2 ** 20 /* 16 MB */ } });
+    let ostream = fp_zip ?
+        fs.createWriteStream(fp_zip, { highWaterMark: 16 * 2 ** 20 /* 16 MB */ })
+        :
+            new WritableMemoryStream();
+    const size = await new Promise(async (resolve, reject) => {
+        ostream.once('close', () => {
+            resolve(archive.pointer());
+        });
+        ostream.once('error', reject);
+        archive.once('error', reject);
+        archive.on('warning', error => {
+            console.log(error);
+        });
+        archive.pipe(ostream);
+        for (const fp in entries) {
+            const fdata = entries[fp];
+            if (fdata instanceof Uint8Array) {
+                if (print.files)
+                    console.log(`压缩 ${fdata.length.to_fsize_str()} -> ${fp}`);
+                archive.append(Buffer.isBuffer(fdata) ? fdata : Buffer.from(fdata.buffer), { name: fp });
+            }
+            else {
+                assert(fp.isdir === fdata.isdir);
+                assert(path.isAbsolute(fdata));
+                if (print.files)
+                    console.log(`压缩 ${fdata} -> ${fp}`);
+                if (fp.isdir)
+                    archive.directory(fdata, fp);
+                else
+                    archive.file(fdata, { name: fp });
+            }
+        }
+        await archive.finalize();
+    });
+    if (print.info)
+        console.log(`压缩完成，总大小 ${size.to_fsize_str()}`);
+    return fp_zip || ostream.pbuffer;
+}
 export let fwatchers = {};
 /** 跟踪文本文件追加的内容，类似 tail -f */
 export async function ftail(fp, handler, { print = true } = {}) {

package/git.d.ts

@@ -0,0 +1,36 @@
+import { type CallOptions } from './process.js';
+export declare class Git {
+    static exe: string;
+    cwd: string;
+    constructor(cwd: string);
+    static init(cwd: string): Promise<Git>;
+    static clone(repo: string, fpd: string): Promise<void>;
+    call(args?: any[], { color, print }?: {
+        color?: boolean;
+        print?: CallOptions['print'];
+    }): Promise<import("./process.js").CallResult<string>>;
+    get_branch(): Promise<string>;
+    /** - print: `true` */
+    get_branches(print?: boolean): Promise<string[]>;
+    has_branch(branch: string): Promise<boolean>;
+    fetch(print?: boolean): Promise<void>;
+    /** - branch?: `'main'` */
+    checkout(branch?: 'main'): Promise<void>;
+    checkout(branch?: string): Promise<void>;
+    _checkout(branch?: string): Promise<void>;
+    merge(branch: string, fast_forward?: boolean): Promise<void>;
+    /** 记住当前分支名
+        checkout 到 <目标分支>
+        merge 当前分支 */
+    merge_into(target_branch?: string): Promise<void>;
+    /** 1. fetch 远程修改
+        2. checkout `<branch>` 分支
+        3. merge `<remote>/<branch>`
+        
+        执行前需要保证工作目录 clean
+        
+        - branch?: `'main'` */
+    update(branch?: 'main'): Promise<void>;
+    update(branch: string): Promise<void>;
+    update(branch: string, remote?: string): Promise<void>;
+}

package/git.js

@@ -0,0 +1,136 @@
+import { assert } from './utils.js';
+import { call } from './process.js';
+import { fread, fmkdir } from './file.js';
+export class Git {
+    static exe = 'git';
+    cwd;
+    constructor(cwd) {
+        this.cwd = cwd;
+    }
+    static async init(cwd) {
+        const git = new Git(cwd);
+        await git.call(['init']);
+        return git;
+    }
+    static async clone(repo, fpd) {
+        await fmkdir(fpd);
+        await new this(fpd).call(['clone', repo, '.']);
+    }
+    async call(args = [], { color = true, print } = {}) {
+        return call(Git.exe, [
+            ...color ? [] : [
+                '-c', 'color.status=false',
+                '-c', 'color.ui=false',
+                '-c', 'color.branch=false',
+            ],
+            ...args,
+        ], {
+            cwd: this.cwd,
+            print,
+        });
+    }
+    async get_branch() {
+        const head = (await fread(`${this.cwd}.git/HEAD`, { print: false })).trim();
+        const branch = head.find('ref: refs/heads/{branch}').branch || head;
+        if (!branch)
+            throw new Error(`${this.cwd} 仓库 Git.get_branch 无法获取到 branch`);
+        return branch;
+        // 需要 100+ ms ，性能太差
+        // this.branch = (await this.git('branch --show-current')).stdout.trim().strip_ansi()
+    }
+    /** - print: `true` */
+    async get_branches(print = true) {
+        return (await this.call(['branch', '-a'], { print })).stdout
+            .split_lines()
+            .map(l => l.strip_ansi())
+            .filter(branch => !branch.includes('origin/HEAD'))
+            .map(branch => branch.rm(/^\* /))
+            .trim_lines();
+    }
+    async has_branch(branch) {
+        return (await this.get_branches(false))
+            .includes(branch);
+    }
+    async fetch(print = true) {
+        if (print)
+            console.log('更新远程分支');
+        await this.call(['fetch', '--all', '--prune'], { print: { code: false, command: false, stdout: true, stderr: true } });
+    }
+    async checkout(branch = 'main') {
+        if (branch === 'main')
+            await this._checkout('main');
+        else {
+            const branches = await this.get_branches(false);
+            if (branches.includes(branch) || branches.find(b => b.endsWith(`/${branch}`) && b.startsWith('remotes/')))
+                await this._checkout(branch);
+            else {
+                console.log(`创建分支 ${branch}`);
+                await this.call(['checkout', '-b', branch], { print: { command: false, code: false, stdout: true, stderr: true } });
+            }
+        }
+    }
+    async _checkout(branch) {
+        try {
+            const { stdout, stderr } = await this.call(['checkout', branch], { print: false });
+            if (stdout)
+                console.log(stdout.trimEnd());
+            console.log(/Already on '.*'\n/.test(stderr) ?
+                `已经在 ${branch} 分支了`
+                : /Switched to branch '.*'/.test(stderr) ?
+                    `已切换到 ${branch} 分支`
+                    :
+                        stderr.trimEnd());
+        }
+        catch (error) {
+            if (error.result) {
+                const { stdout, stderr } = error.result;
+                if (stdout)
+                    console.log(stdout);
+                if (stderr)
+                    console.log(stderr);
+            }
+            throw error;
+        }
+    }
+    async merge(branch, fast_forward = true) {
+        console.log(`合并 ${branch} 分支`);
+        try {
+            const { stdout, stderr } = await this.call([
+                'merge',
+                branch,
+                ...fast_forward ? [] : ['--no-ff']
+            ], { print: false });
+            if (stdout === 'Already up to date.\n')
+                console.log('当前分支无需更新');
+            else
+                console.log(stdout.trimEnd());
+            if (stderr)
+                console.log(stderr);
+        }
+        catch (error) {
+            if (error.result) {
+                const { stdout, stderr } = error.result;
+                if (stdout)
+                    console.log(stdout);
+                if (stderr)
+                    console.log(stderr);
+            }
+            throw error;
+        }
+    }
+    /** 记住当前分支名
+        checkout 到 <目标分支>
+        merge 当前分支 */
+    async merge_into(target_branch = 'main') {
+        const branch = await this.get_branch();
+        assert(branch !== target_branch);
+        await this.checkout(target_branch);
+        await this.merge(branch, true);
+    }
+    async update(branch = 'main', remote = 'origin') {
+        await this.fetch();
+        await this.checkout(branch);
+        await this.merge(`${remote}/${branch}`);
+    }
+}
+//# sourceMappingURL=git.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xshell",
-  "version": "1.0.65",
+  "version": "1.0.67",
   "type": "module",
   "main": "./index.js",
   "bin": {
@@ -50,6 +50,8 @@
     "@babel/traverse": "^7.23.5",
     "@koa/cors": "^4.0.0",
     "@types/ws": "^8.5.10",
+    "ali-oss": "^6.18.1",
+    "archiver": "^6.0.1",
     "byte-size": "^8.1.1",
     "chalk": "^5.3.0",
     "chardet": "^2.0.0",
@@ -91,6 +93,8 @@
   },
   "devDependencies": {
     "@babel/types": "^7.23.5",
+    "@types/ali-oss": "^6.16.11",
+    "@types/archiver": "^6.0.2",
     "@types/babel__traverse": "^7.20.4",
     "@types/byte-size": "^8.1.2",
     "@types/chardet": "^0.8.3",

package/process.d.ts

@@ -6,6 +6,8 @@ import './prototype.js';
 import { Encoding } from './file.js';
 import { inspect } from './utils.js';
 export declare const exe_nodejs: string;
+export declare const platform: NodeJS.Platform;
+export declare const username: string;
 interface StartOptions {
     /** `继承当前工作目录 process.cwd()` 子进程的工作目录  `inherit the cwd` cwd of the child process. */
     cwd?: string;
@@ -108,8 +110,7 @@ export declare const exe_winterm: string;
 /** 新建 terminal 窗口执行进程  New Terminal window execution process
     - exe: exe 文件路径  exe file path
     - args: 调用参数  call parameter
-    - options?: WinTermOptions
-*/
+    - options?: WinTermOptions */
 export declare function term(exe: string, args?: string[], { cwd, print, title, }?: TermOptions): Promise<ChildProcess>;
 export interface TermNodeOptions extends TermOptions {
     /** nodejs debugger port */

package/process.js

@@ -1,9 +1,11 @@
 import { spawn } from 'child_process';
-import { userInfo } from 'os';
+import os from 'os';
 import { t } from './i18n/instance.js';
 import './prototype.js';
 import { inspect, DecoderStream } from './utils.js';
 export const exe_nodejs = process.execPath.fp;
+export const platform = os.platform();
+export const username = os.userInfo().username;
 /** start process
     - exe: .exe 路径或文件名 (建议使用完整路径，跳过 path 搜索，性能更高)  path or filename (full path is recommanded to skip path searching for better perf)
     - args: `[]` 参数列表  arguments list
@@ -184,12 +186,11 @@ export async function call_nodejs(js, args = [], { inspect, break: _break, ...op
         ...args
     ], options);
 }
-export const exe_winterm = `C:/Users/${userInfo().username}/AppData/Local/Microsoft/WindowsApps/wt.exe`;
+export const exe_winterm = `C:/Users/${username}/AppData/Local/Microsoft/WindowsApps/wt.exe`;
 /** 新建 terminal 窗口执行进程  New Terminal window execution process
     - exe: exe 文件路径  exe file path
     - args: 调用参数  call parameter
-    - options?: WinTermOptions
-*/
+    - options?: WinTermOptions */
 export async function term(exe, args = [], { cwd = process.cwd().fpd, print = true, title,
 // env
  } = {}) {

package/utils.browser.d.ts

@@ -51,7 +51,7 @@ 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;
+export declare function strcmp(l: string, r: string): 1 | 0 | -1;
 /** 比较 1.10.02 这种版本号 */
 export declare function vercmp(l: string, r: string): number;
 export declare function get<TReturn = any>(obj: any, keypath: string): TReturn;

package/utils.d.ts

@@ -22,7 +22,7 @@ export declare function unique<T>(iterable: T[] | Iterable<T>, selector?: string
 /** 排序对象中 key 的顺序，返回新的对象 */
 export declare function sort_keys<T>(obj: T): T;
 /** 字符串字典序比较 */
-export declare function strcmp(l: string, r: string): 0 | 1 | -1;
+export declare function strcmp(l: string, r: string): 1 | 0 | -1;
 /** 比较 1.10.02 这种版本号 */
 export declare function vercmp(l: string, r: string): number;
 export declare function get<TReturn = any>(obj: any, keypath: string): TReturn;