xshell 1.0.64 → 1.0.66

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/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.64",
+  "version": "1.0.66",
   "type": "module",
   "main": "./index.js",
   "bin": {

package/server.d.ts

@@ -1,8 +1,10 @@
 /// <reference types="node" resolution-mode="require"/>
 /// <reference types="node" resolution-mode="require"/>
 /// <reference types="node" resolution-mode="require"/>
-import { type Server as HttpServer, type IncomingHttpHeaders } from 'http';
+/// <reference types="node" resolution-mode="require"/>
+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 type { default as Koa, Context, Next } from 'koa';
 declare module 'koa' {
@@ -70,6 +72,7 @@ export declare class Server {
     on_error(error: Error & {
         code?: string;
     }, ctx?: Context): void;
+    on_upgrade(request: IncomingMessage, socket: Duplex, head: Buffer): void;
     /** 可被子类重写添加额外的中间件，在 start 时被调用 */
     init_app(app: Koa): Promise<void>;
     entry(ctx: Context, next: Next): Promise<void>;

package/server.js

@@ -1,4 +1,4 @@
-import { createServer as http_create_server } from 'http';
+import { createServer as http_create_server, } from 'http';
 import { createSecureServer as http2_create_server } from 'http2';
 import { createSecureContext } from 'tls';
 import zlib from 'zlib';
@@ -128,37 +128,9 @@ export class Server {
                     this.remote.handle(new Uint8Array(data), ws);
                 });
             });
-            this.http_server.on('upgrade', (request, socket, head) => {
-                // url 只有路径部分
-                const { url, headers, headers: { host = '' }, } = request;
-                const ip = request.socket.remoteAddress.replace(/^::ffff:/, '');
-                console.log(
-                // 时间
-                `${new Date().to_time_str()}  ` +
-                    // ip（位置）
-                    (ip || '').limit(60) + '  ' +
-                    // ua
-                    this.format_ua(headers).limit(56) + '  ' +
-                    // https／2.0
-                    `${this.colors ? 'websocket'.limit(10).magenta : 'websocket'.limit(10)}  ` +
-                    // method
-                    ''.limit(6) + ' ' +
-                    // host
-                    `${host.limit(24)}  ` +
-                    // path
-                    (this.colors ? url.yellow : url));
-                switch (url) {
-                    case '/':
-                        this.websocket_server.handleUpgrade(request, socket, head, ws => {
-                            ws.binaryType = 'arraybuffer';
-                            this.websocket_server.emit('connection', ws, request);
-                        });
-                        return;
-                    default:
-                        console.log(`${' '.repeat(13)}    connect 404: ${url}`.red);
-                        socket.destroy();
-                }
-            });
+            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 = {
@@ -246,6 +218,37 @@ export class Server {
             console.log(ctx);
         }
     }
+    on_upgrade(request, socket, head) {
+        // url 只有路径部分
+        const { url, headers, headers: { host = '' }, } = request;
+        const ip = request.socket.remoteAddress.replace(/^::ffff:/, '');
+        console.log(
+        // 时间
+        `${new Date().to_time_str()}  ` +
+            // ip（位置）
+            (ip || '').limit(60) + '  ' +
+            // ua
+            this.format_ua(headers).limit(56) + '  ' +
+            // https／2.0
+            `${this.colors ? 'websocket'.limit(10).magenta : 'websocket'.limit(10)}  ` +
+            // method
+            ''.limit(6) + ' ' +
+            // host
+            `${host.limit(24)}  ` +
+            // path
+            (this.colors ? url.yellow : url));
+        switch (url) {
+            case '/':
+                this.websocket_server.handleUpgrade(request, socket, head, ws => {
+                    ws.binaryType = 'arraybuffer';
+                    this.websocket_server.emit('connection', ws, request);
+                });
+                return;
+            default:
+                console.log(`${' '.repeat(13)}    connect 404: ${url}`.red);
+                socket.destroy();
+        }
+    }
     /** 可被子类重写添加额外的中间件，在 start 时被调用 */
     async init_app(app) {
     }