@maiyunnet/kebab 2.0.4 → 2.0.6

package/lib/kv.d.ts

@@ -0,0 +1,111 @@
+import * as redis from '@litert/redis';
+import * as ctr from '../sys/ctr';
+import * as types from '../types';
+export interface IConnectionInfo {
+    'id': number;
+    'last': number;
+    'host': string;
+    'port': number;
+    'index': number;
+    'lost': boolean;
+}
+export declare class Pool {
+    private readonly _etc;
+    constructor(ctr: ctr.Ctr, etc?: types.IConfigKv);
+    set(key: string, val: object | string | number, ttl?: number, mod?: '' | 'nx' | 'xx'): Promise<boolean>;
+    add(key: string, val: object | string | number, ttl?: number): Promise<boolean>;
+    replace(key: string, val: object | string | number, ttl?: number): Promise<boolean>;
+    append(key: string, val: string): Promise<boolean>;
+    prepend(key: string, val: string): Promise<boolean>;
+    exists(keys: string | string[]): Promise<number>;
+    get(key: string): Promise<string | null>;
+    ttl(key: string): Promise<number | null>;
+    pttl(key: string): Promise<number | null>;
+    mSet(rows: Record<string, string | Buffer>): Promise<boolean>;
+    mGet(keys: string[]): Promise<Record<string, string | null>>;
+    getJson(key: string): Promise<any | null>;
+    del(keys: string | string[]): Promise<boolean>;
+    incr(key: string, num?: number): Promise<number | false>;
+    decr(key: string, num?: number): Promise<number | false>;
+    expire(key: string, ttl: number): Promise<boolean>;
+    keys(pattern: string): Promise<string[] | false>;
+    scan(cursor?: number, pattern?: string, count?: number): Promise<redis.IScanResult<string> | false>;
+    flushDb(): Promise<boolean>;
+    ping(): Promise<string | false>;
+    hSet(key: string, field: string, val: object | string | number, mod?: '' | 'nx'): Promise<boolean>;
+    hMSet(key: string, rows: Record<string, object | string | number>): Promise<boolean>;
+    hGet(key: string, field: string): Promise<string | null>;
+    hGetJson(key: string, field: string): Promise<any | null>;
+    hMGet(key: string, fields: string[]): Promise<Record<string, string | null>>;
+    hGetAll(key: string): Promise<Record<string, string | null> | null>;
+    hDel(key: string, fields: string | string[]): Promise<number>;
+    hExists(key: string, field: string): Promise<boolean>;
+    hIncr(key: string, field: string, increment: number): Promise<number>;
+    hKeys(key: string): Promise<string[]>;
+    lPush(key: string, values: Array<string | Buffer>): Promise<number>;
+    rPush(key: string, values: Array<string | Buffer>): Promise<number>;
+    bLMove(sourceKey: string, destKey: string, soo: 'LEFT' | 'RIGHT', deo: 'LEFT' | 'RIGHT', timeout: number): Promise<string | null>;
+    lPop(key: string): Promise<string | null>;
+    rPop(key: string): Promise<string | null>;
+    bRPop(key: string | string[], timeout: number): Promise<Record<string, string>>;
+    lRange(key: string, start: number, stop: number): Promise<string[]>;
+    lLen(key: string): Promise<number>;
+    private _getConnection;
+}
+export declare class Connection {
+    private _last;
+    private readonly _link;
+    private _using;
+    private _lost;
+    private readonly _etc;
+    constructor(etc: types.IConfigKv, link: redis.ICommandClient);
+    getEtc(): types.IConfigKv;
+    getLast(): number;
+    setLost(): void;
+    isLost(): boolean;
+    setUsing(): void;
+    isUsing(): boolean;
+    used(): void;
+    refreshLast(): void;
+    end(): Promise<void>;
+    set(key: string, val: object | string | number, ttl: number, mod: '' | 'nx' | 'xx', etc: types.IConfigKv): Promise<boolean>;
+    add(key: string, val: object | string | number, ttl: number, etc: types.IConfigKv): Promise<boolean>;
+    replace(key: string, val: object | string | number, ttl: number, etc: types.IConfigKv): Promise<boolean>;
+    append(key: string, val: string, etc: types.IConfigKv): Promise<boolean>;
+    prepend(key: string, val: string, etc: types.IConfigKv): Promise<boolean>;
+    exists(keys: string | string[], etc: types.IConfigKv): Promise<number>;
+    get(key: string, etc: types.IConfigKv): Promise<string | null>;
+    ttl(key: string, etc: types.IConfigKv): Promise<number | null>;
+    pttl(key: string, etc: types.IConfigKv): Promise<number | null>;
+    mGet(keys: string[], etc: types.IConfigKv): Promise<Record<string, string | null>>;
+    mSet(rows: Record<string, string | Buffer>, etc: types.IConfigKv): Promise<boolean>;
+    getJson(key: string, etc: types.IConfigKv): Promise<any | null>;
+    del(keys: string | string[], etc: types.IConfigKv): Promise<boolean>;
+    incr(key: string, num: number, etc: types.IConfigKv): Promise<number | false>;
+    decr(key: string, num: number, etc: types.IConfigKv): Promise<number | false>;
+    expire(key: string, ttl: number, etc: types.IConfigKv): Promise<boolean>;
+    keys(pattern: string, etc: types.IConfigKv): Promise<string[] | false>;
+    scan(cursor: number, pattern: string, count: number, etc: types.IConfigKv): Promise<redis.IScanResult<string> | false>;
+    flushDb(): Promise<boolean>;
+    ping(): Promise<false | string>;
+    hSet(key: string, field: string, val: object | string | number, mod: '' | 'nx', etc: types.IConfigKv): Promise<boolean>;
+    hMSet(key: string, rows: Record<string, object | string | number>, etc: types.IConfigKv): Promise<boolean>;
+    hGet(key: string, field: string, etc: types.IConfigKv): Promise<string | null>;
+    hGetJson(key: string, field: string, etc: types.IConfigKv): Promise<any | null>;
+    hMGet(key: string, fields: string[], etc: types.IConfigKv): Promise<Record<string, string | null>>;
+    hGetAll(key: string, etc: types.IConfigKv): Promise<Record<string, string | null> | null>;
+    hDel(key: string, fields: string | string[], etc: types.IConfigKv): Promise<number>;
+    hExists(key: string, field: string, etc: types.IConfigKv): Promise<boolean>;
+    hIncr(key: string, field: string, increment: number, etc: types.IConfigKv): Promise<number>;
+    hKeys(key: string, etc: types.IConfigKv): Promise<string[]>;
+    lPush(key: string, values: Array<string | Buffer>, etc: types.IConfigKv): Promise<number>;
+    rPush(key: string, values: Array<string | Buffer>, etc: types.IConfigKv): Promise<number>;
+    bLMove(sourceKey: string, destKey: string, soo: 'LEFT' | 'RIGHT', deo: 'LEFT' | 'RIGHT', timeout: number, etc: types.IConfigKv): Promise<string | null>;
+    lPop(key: string, etc: types.IConfigKv): Promise<string | null>;
+    rPop(key: string, etc: types.IConfigKv): Promise<string | null>;
+    bRPop(key: string | string[], timeout: number, etc: types.IConfigKv): Promise<Record<string, string>>;
+    lRange(key: string, start: number, stop: number, etc: types.IConfigKv): Promise<string[]>;
+    lLen(key: string, etc: types.IConfigKv): Promise<number>;
+}
+export declare function get(ctr: ctr.Ctr, etc?: types.IConfigKv): Pool;
+export declare function getConnectionList(): IConnectionInfo[];

package/lib/kv.js

@@ -37,8 +37,8 @@ exports.Connection = exports.Pool = void 0;
 exports.get = get;
 exports.getConnectionList = getConnectionList;
 const redis = __importStar(require("@litert/redis"));
-const time = __importStar(require("~/lib/time"));
-const text = __importStar(require("~/lib/text"));
+const time = __importStar(require("../lib/time"));
+const text = __importStar(require("../lib/text"));
 const connections = [];
 async function checkConnection() {
     const now = time.stamp();

package/lib/lan.d.ts

@@ -0,0 +1,10 @@
+export declare function card(): Promise<Array<{
+    'name': string;
+    'mac': string;
+    'iPv4': string;
+    'iPv6': string;
+}>>;
+export declare function scan(): Promise<Array<{
+    'mac': string;
+    'iPv4': string;
+}>>;

package/lib/lan.js

@@ -36,7 +36,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.card = card;
 exports.scan = scan;
 const os = __importStar(require("os"));
-const lCore = __importStar(require("~/lib/core"));
+const lCore = __importStar(require("../lib/core"));
 async function card() {
     const result = [];
     let i = 0;

package/lib/net/formdata.d.ts

@@ -0,0 +1,23 @@
+import * as stream from 'stream';
+export interface IItem {
+    'key': string;
+    'isFile': boolean;
+    'isString': boolean;
+    'value': string;
+    'path': string;
+}
+export declare class FormData extends stream.Readable {
+    private _num;
+    private readonly _data;
+    private readonly _boundary;
+    private _fileReading;
+    private _close;
+    private _length;
+    private _sent;
+    putString(key: string, val: string): void;
+    putFile(key: string, path: string, fname?: string): Promise<boolean>;
+    getBoundary(): string;
+    getLength(): number;
+    getSent(): number;
+    _read(): void;
+}

package/lib/net/formdata.js

@@ -36,8 +36,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.FormData = void 0;
 const stream = __importStar(require("stream"));
 const mime = __importStar(require("@litert/mime"));
-const core = __importStar(require("~/lib/core"));
-const fs = __importStar(require("~/lib/fs"));
+const core = __importStar(require("../../lib/core"));
+const fs = __importStar(require("../../lib/fs"));
 class FormData extends stream.Readable {
     constructor() {
         super(...arguments);

package/lib/net/request.d.ts

@@ -0,0 +1,23 @@
+import * as stream from 'stream';
+import * as response from './response';
+import * as types from '../../types';
+export declare class Request {
+    private _data;
+    private readonly _url;
+    private _opt;
+    constructor(url: string);
+    data(data: Record<string, any> | Buffer | string | stream.Readable): this;
+    method(method: 'GET' | 'POST'): this;
+    get(): this;
+    post(): this;
+    type(type: 'form' | 'json'): this;
+    json(): this;
+    timeout(timeout: number): this;
+    follow(follow?: number): this;
+    hosts(hosts: Record<string, string>): this;
+    save(save: string): this;
+    local(addr: string): this;
+    headers(headers: types.THttpHeaders): this;
+    setHeader(name: string, val: string): this;
+    request(cookie?: Record<string, types.ICookie>): Promise<response.Response>;
+}

package/lib/net/request.js

@@ -34,7 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Request = void 0;
-const net = __importStar(require("~/lib/net"));
+const net = __importStar(require("../../lib/net"));
 class Request {
     constructor(url) {
         this._data = undefined;

package/lib/net/response.d.ts

@@ -0,0 +1,14 @@
+import * as hc from '@litert/http-client';
+import * as nStream from 'stream';
+import * as types from '../../types';
+export declare class Response {
+    private readonly _req;
+    headers: types.THttpHeaders | null;
+    error: Error | null;
+    private _content;
+    constructor(req: hc.IResponse | null);
+    getContent(): Promise<Buffer | null>;
+    setContent(v: string | Buffer): void;
+    getStream(): nStream.Readable;
+    getRawStream(): nStream.Readable;
+}

package/lib/net.d.ts

@@ -0,0 +1,65 @@
+import * as stream from 'stream';
+import * as http from 'http';
+import * as http2 from 'http2';
+import * as ctr from '../sys/ctr';
+import * as types from '../types';
+import * as fd from './net/formdata';
+import * as lRequest from './net/request';
+import * as response from './net/response';
+export interface IRequestOptions {
+    'method'?: 'GET' | 'POST' | 'OPTIONS';
+    'type'?: 'form' | 'json';
+    'timeout'?: number;
+    'follow'?: number;
+    'hosts'?: Record<string, string>;
+    'save'?: string;
+    'local'?: string;
+    'headers'?: types.THttpHeaders;
+    'mproxy'?: {
+        'url': string;
+        'auth': string;
+        'data'?: any;
+    };
+    'reuse'?: string;
+    'cookie'?: Record<string, types.ICookie>;
+}
+export interface IMproxyOptions {
+    'timeout'?: number;
+    'follow'?: number;
+    'hosts'?: Record<string, string>;
+    'local'?: string;
+    'headers'?: types.THttpHeaders;
+    'reuse'?: string;
+}
+export interface IRproxyOptions {
+    'timeout'?: number;
+    'follow'?: number;
+    'hosts'?: Record<string, string>;
+    'local'?: string;
+    'headers'?: types.THttpHeaders;
+    'mproxy'?: {
+        'url': string;
+        'auth': string;
+        'data'?: any;
+    };
+    'reuse'?: string;
+}
+export declare function getCa(): Promise<string>;
+export declare function open(u: string): lRequest.Request;
+export declare function get(u: string, opt?: IRequestOptions): Promise<response.Response>;
+export declare function post(u: string, data: Record<string, types.Json> | Buffer | string | stream.Readable, opt?: IRequestOptions): Promise<response.Response>;
+export declare function postJson(u: string, data: types.Json[] | Record<string, types.Json>, opt?: IRequestOptions): Promise<response.Response>;
+export declare function request(u: string, data?: Record<string, types.Json> | Buffer | string | stream.Readable, opt?: IRequestOptions): Promise<response.Response>;
+export declare function setCookie(cookie: Record<string, types.ICookie>, name: string, value: string, domain: string, opt?: {
+    'ttl'?: number;
+    'path'?: string;
+    'ssl'?: boolean;
+    'httponly'?: boolean;
+}): void;
+export declare function buildCookieQuery(cookie: Record<string, types.ICookie>, uri: types.IUrlParse): string;
+export declare function resetCookieSession(cookie: Record<string, types.ICookie>): void;
+export declare function getFormData(): fd.FormData;
+export declare function filterProxyHeaders(headers: http.IncomingHttpHeaders | http2.IncomingHttpHeaders | types.THttpHeaders, res?: http2.Http2ServerResponse | http.ServerResponse): Record<string, string | string[]>;
+export declare function mproxy(ctr: ctr.Ctr, auth: string, opt?: IMproxyOptions): Promise<number>;
+export declare function mproxyData(ctr: ctr.Ctr): any;
+export declare function rproxy(ctr: ctr.Ctr, route: Record<string, string>, opt?: IRproxyOptions): Promise<boolean>;

package/lib/net.js

@@ -49,10 +49,10 @@ exports.mproxyData = mproxyData;
 exports.rproxy = rproxy;
 const stream = __importStar(require("stream"));
 const hc = __importStar(require("@litert/http-client"));
-const fs = __importStar(require("~/lib/fs"));
-const text = __importStar(require("~/lib/text"));
-const time = __importStar(require("~/lib/time"));
-const kebab = __importStar(require("~/index"));
+const fs = __importStar(require("../lib/fs"));
+const text = __importStar(require("../lib/text"));
+const time = __importStar(require("../lib/time"));
+const kebab = __importStar(require("../index"));
 const fd = __importStar(require("./net/formdata"));
 const lRequest = __importStar(require("./net/request"));
 const response = __importStar(require("./net/response"));

package/lib/s3.d.ts

@@ -0,0 +1,35 @@
+import * as s3 from '@aws-sdk/client-s3';
+import * as stream from 'stream';
+import * as sCtr from '../sys/ctr';
+export declare enum ESERVICE {
+    'AMAZON' = 0,
+    'TENCENT' = 1,
+    'ALIBABA' = 2,
+    'CF' = 3
+}
+export interface IOptions {
+    'service': ESERVICE;
+    'account'?: string;
+    'secretId'?: string;
+    'secretKey'?: string;
+    'region'?: string;
+    'bucket'?: string;
+}
+export declare class S3 {
+    private readonly _link;
+    private _bucket;
+    private readonly _ctr;
+    constructor(ctr: sCtr.Ctr, opt: IOptions);
+    setBucket(bucket: string): void;
+    putObject(key: string, content: string | Buffer | stream.Readable, length?: number | {
+        'length'?: number;
+        'type'?: string;
+        'disposition'?: string;
+        'bucket'?: string;
+    }, bucket?: string): Promise<s3.CompleteMultipartUploadCommandOutput | false>;
+    getObject(key: string, bucket?: string): Promise<false | (stream.Readable & import("@smithy/types").SdkStreamMixin) | (Blob & import("@smithy/types").SdkStreamMixin) | (ReadableStream<any> & import("@smithy/types").SdkStreamMixin) | undefined>;
+    deleteObject(key: string, bucket?: string): Promise<boolean>;
+    deleteObjects(keys: string[], bucket?: string): Promise<boolean>;
+    headObject(key: string, bucket?: string): Promise<s3.HeadObjectCommandOutput | false>;
+}
+export declare function get(ctr: sCtr.Ctr, opt: IOptions): S3;

package/lib/s3.js

@@ -37,8 +37,8 @@ exports.S3 = exports.ESERVICE = void 0;
 exports.get = get;
 const s3 = __importStar(require("@aws-sdk/client-s3"));
 const ls = __importStar(require("@aws-sdk/lib-storage"));
-const lCore = __importStar(require("~/lib/core"));
-const lText = __importStar(require("~/lib/text"));
+const lCore = __importStar(require("../lib/core"));
+const lText = __importStar(require("../lib/text"));
 var ESERVICE;
 (function (ESERVICE) {
     ESERVICE[ESERVICE["AMAZON"] = 0] = "AMAZON";

package/lib/scan.d.ts

@@ -0,0 +1,31 @@
+import * as lDb from '../lib/db';
+import * as lKv from '../lib/kv';
+import * as sCtr from '../sys/ctr';
+export interface IOptions {
+    'ttl'?: number;
+    'sqlPre'?: sCtr.Ctr | string;
+    'name'?: string;
+}
+export interface IStaticOptions {
+    'sqlPre'?: sCtr.Ctr | string;
+    'name'?: string;
+}
+export declare class Scan {
+    private readonly _link;
+    private readonly _sql;
+    private readonly _name;
+    private _token;
+    private _ttl;
+    constructor(link: lDb.Pool | lKv.Pool, token?: string, opt?: IOptions);
+    private _timeLeft;
+    poll(): Promise<any>;
+    createToken(): Promise<boolean>;
+    getToken(): string | null;
+    setTTL(ttl: number): void;
+    getTTL(): number;
+    getTimeLeft(): number | null;
+    private _gc;
+}
+export declare function get(link: lDb.Pool | lKv.Pool, token?: string, opt?: IOptions): Promise<Scan>;
+export declare function scanned(link: lDb.Pool | lKv.Pool, token: string, opt?: IStaticOptions): Promise<boolean>;
+export declare function setData(link: lDb.Pool | lKv.Pool, token: string, data: Record<string, any> | string | number, opt?: IStaticOptions): Promise<boolean>;

package/lib/scan.js

@@ -37,12 +37,12 @@ exports.Scan = void 0;
 exports.get = get;
 exports.scanned = scanned;
 exports.setData = setData;
-const lCore = __importStar(require("~/lib/core"));
-const lDb = __importStar(require("~/lib/db"));
-const lKv = __importStar(require("~/lib/kv"));
-const lSql = __importStar(require("~/lib/sql"));
-const lTime = __importStar(require("~/lib/time"));
-const lText = __importStar(require("~/lib/text"));
+const lCore = __importStar(require("../lib/core"));
+const lDb = __importStar(require("../lib/db"));
+const lKv = __importStar(require("../lib/kv"));
+const lSql = __importStar(require("../lib/sql"));
+const lTime = __importStar(require("../lib/time"));
+const lText = __importStar(require("../lib/text"));
 class Scan {
     constructor(link, token, opt = {}) {
         this._sql = null;

package/lib/session.d.ts

@@ -0,0 +1,22 @@
+import * as db from '../lib/db';
+import * as kv from '../lib/kv';
+import * as ctr from '../sys/ctr';
+export interface IOptions {
+    'name'?: string;
+    'ttl'?: number;
+    'ssl'?: boolean;
+    'sqlPre'?: string;
+}
+export declare class Session {
+    private _link;
+    private _sql;
+    private _name;
+    private _token;
+    private _ttl;
+    private _ctr;
+    init(ctr: ctr.Ctr, link: db.Pool | kv.Pool, auth?: boolean, opt?: IOptions): Promise<boolean>;
+    getToken(): string;
+    getName(): string;
+    update(): Promise<void>;
+    private _gc;
+}

package/lib/session.js

@@ -34,12 +34,12 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Session = void 0;
-const core = __importStar(require("~/lib/core"));
-const time = __importStar(require("~/lib/time"));
-const db = __importStar(require("~/lib/db"));
-const kv = __importStar(require("~/lib/kv"));
-const sql = __importStar(require("~/lib/sql"));
-const text = __importStar(require("~/lib/text"));
+const core = __importStar(require("../lib/core"));
+const time = __importStar(require("../lib/time"));
+const db = __importStar(require("../lib/db"));
+const kv = __importStar(require("../lib/kv"));
+const sql = __importStar(require("../lib/sql"));
+const text = __importStar(require("../lib/text"));
 class Session {
     constructor() {
         this._token = '';

package/lib/sql.d.ts

@@ -0,0 +1,57 @@
+import * as ctr from '../sys/ctr';
+import * as types from '../types';
+export declare class Sql {
+    private readonly _pre;
+    private _sql;
+    private _data;
+    constructor(pre?: string, opt?: {
+        'data'?: types.DbValue[];
+        'sql'?: string[];
+    });
+    insert(table: string): this;
+    replace(table: string): this;
+    values(cs: string[] | Record<string, types.DbValue>, vs?: types.DbValue[] | types.DbValue[][]): this;
+    notExists(table: string, insert: Record<string, types.DbValue>, where: string | types.Json): this;
+    duplicate(s: types.Json): this;
+    select(c: string | Array<string | Array<string | string[]>>, f: string | string[]): this;
+    update(f: string, s: types.Json): this;
+    private _updateSub;
+    delete(f: string): this;
+    union(lsql: Sql, type?: string): this;
+    unionAll(lsql: Sql): this;
+    join(f: string, s?: types.Json, type?: string, suf?: string, pre?: string): this;
+    leftJoin(f: string, s?: types.Json, suf?: string, pre?: string): this;
+    rightJoin(f: string, s?: types.Json, suf?: string, pre?: string): this;
+    innerJoin(f: string, s?: types.Json, suf?: string, pre?: string): this;
+    fullJoin(f: string, s?: types.Json, suf?: string, pre?: string): this;
+    crossJoin(f: string, s?: types.Json, suf?: string, pre?: string): this;
+    having(s?: string | types.Json): this;
+    private _whereDataPosition;
+    where(s: string | types.Json): this;
+    private _whereSub;
+    by(c: string | Array<string | string[]>, d?: 'DESC' | 'ASC'): this;
+    group(c: string | string[]): this;
+    limit(a: number, b?: number): this;
+    lock(): this;
+    copy(f?: string | string[], opt?: {
+        'where'?: string | types.Json;
+    }): Sql;
+    getSql(): string;
+    getData(): types.DbValue[];
+    getPre(): string;
+    format(sql?: string, data?: types.DbValue[]): string;
+    append(sql: string): this;
+    field(str: string | number | Array<string | string[]>, pre?: string, suf?: string): string;
+    private _isField;
+}
+export declare function get(ctrPre?: ctr.Ctr | string, opt?: {
+    'data'?: types.DbValue[];
+    'sql'?: string[];
+}): Sql;
+export declare function format(sql: string, data: types.DbValue[]): string;
+export declare function aoMix(arr: types.Json): Record<string, string | number | types.Json>;
+export declare function column(field: string): {
+    'type': 'column';
+    'token': string;
+    'value': string;
+};

package/lib/sql.js

@@ -38,10 +38,10 @@ exports.get = get;
 exports.format = format;
 exports.aoMix = aoMix;
 exports.column = column;
-const lText = __importStar(require("~/lib/text"));
-const lCore = __importStar(require("~/lib/core"));
+const lText = __importStar(require("../lib/text"));
+const lCore = __importStar(require("../lib/core"));
 const mysql2 = __importStar(require("mysql2/promise"));
-const ctr = __importStar(require("~/sys/ctr"));
+const ctr = __importStar(require("../sys/ctr"));
 let columnToken = '';
 class Sql {
     constructor(pre, opt = {}) {

package/lib/ssh/sftp.d.ts

@@ -0,0 +1,40 @@
+import * as stream from 'stream';
+import * as ssh2 from 'ssh2';
+export declare class Connection {
+    private readonly _client;
+    private _path;
+    constructor(sftp: ssh2.SFTPWrapper, path: string);
+    getContent(path: string, options?: {
+        'start'?: number;
+        'end'?: number;
+    }): Promise<Buffer | null>;
+    getContent(path: string, options: BufferEncoding | {
+        'encoding': BufferEncoding;
+        'start'?: number;
+        'end'?: number;
+    }): Promise<string | null>;
+    putContent(path: string, data: string | Buffer, options?: ssh2.WriteFileOptions): Promise<boolean>;
+    readLink(path: string): Promise<string | null>;
+    symlink(filePath: string, linkPath: string): Promise<boolean>;
+    unlink(path: string): Promise<boolean>;
+    private _unlink;
+    stats(path: string): Promise<ssh2.Stats | null>;
+    isDir(path: string): Promise<ssh2.Stats | false>;
+    isFile(path: string): Promise<ssh2.Stats | false>;
+    mkdir(path: string, mode?: number): Promise<boolean>;
+    rmdir(path: string): Promise<boolean>;
+    rmdirDeep(path: string): Promise<boolean>;
+    chmod(path: string, mode: string | number): Promise<boolean>;
+    rename(oldPath: string, newPath: string): Promise<boolean>;
+    readDir(path: string): Promise<ssh2.FileEntry[]>;
+    createReadStream(path: string, options?: ssh2.ReadStreamOptions): stream.Readable;
+    pipe<T extends NodeJS.WritableStream>(path: string, destination: T, options?: {
+        'end'?: boolean;
+    }): Promise<boolean>;
+    createWriteStream(path: string, options?: BufferEncoding | ssh2.WriteStreamOptions): stream.Writable;
+    pwd(): string;
+    downloadFile(remoteFile: string, localFile: string, options?: ssh2.TransferOptions): Promise<boolean>;
+    uploadFile(localFile: string, remoteFile: string, options?: ssh2.TransferOptions): Promise<boolean>;
+    cd(dir: string): string;
+    close(): void;
+}

package/lib/ssh/sftp.js

@@ -34,8 +34,8 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Connection = void 0;
-const core = __importStar(require("~/lib/core"));
-const text = __importStar(require("~/lib/text"));
+const core = __importStar(require("../../lib/core"));
+const text = __importStar(require("../../lib/text"));
 class Connection {
     constructor(sftp, path) {
         this._client = sftp;

package/lib/ssh/shell.d.ts

@@ -0,0 +1,13 @@
+import * as ssh2 from 'ssh2';
+export declare class Connection {
+    private readonly _client;
+    constructor(stream: ssh2.ClientChannel);
+    send(cmd: string | Buffer, encoding?: BufferEncoding): Promise<boolean>;
+    sendLine(cmd: string, encoding?: BufferEncoding): Promise<boolean>;
+    sendEnter(): Promise<boolean>;
+    sendTab(): Promise<boolean>;
+    sendCtrlC(): Promise<boolean>;
+    close(cmd?: string | Buffer, encoding?: BufferEncoding): Promise<void>;
+    getContent(tryCount?: number): Promise<Buffer>;
+    getStream(): ssh2.ClientChannel;
+}

package/lib/ssh/shell.js

@@ -34,7 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Connection = void 0;
-const lCore = __importStar(require("~/lib/core"));
+const lCore = __importStar(require("../../lib/core"));
 class Connection {
     constructor(stream) {
         this._client = stream;

package/lib/ssh.d.ts

@@ -0,0 +1,24 @@
+import * as ssh2 from 'ssh2';
+import * as shell from './ssh/shell';
+import * as sftp from './ssh/sftp';
+interface IExtOptions {
+    'mproxy'?: {
+        'host': string;
+        'port': number;
+        'username': string;
+        'password': string;
+    };
+}
+export declare class Connection {
+    private readonly _client;
+    private _mclient?;
+    constructor();
+    connect(opt: ssh2.ConnectConfig & IExtOptions): Promise<boolean>;
+    disconnect(): void;
+    exec(command: string): Promise<Buffer | false>;
+    getShell(): Promise<shell.Connection | null>;
+    getSftp(): Promise<sftp.Connection | null>;
+    getStream(): Promise<ssh2.ClientChannel | null>;
+}
+export declare function get(opt: ssh2.ConnectConfig & IExtOptions): Promise<Connection | null>;
+export {};