ssh2-scp 1.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 ZHAO Xudong
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README-CN.md

@@ -0,0 +1,126 @@
+# ssh2-scp
+
+通过 SSH2 会话进行远程文件系统操作（无需 SFTP）。
+
+[English](./README.md)
+
+## 特性
+
+- 通过 SSH2 shell/command 会话进行文件操作（无需 SFTP）
+- 支持所有常用文件系统操作
+- 同时支持 ESM 和 CJS 导出
+- 支持 TypeScript
+
+## 安装
+
+```bash
+npm install ssh2-scp
+```
+
+## 使用方法
+
+```javascript
+import { Client } from 'ssh2'
+import { createSshFs } from 'ssh2-scp'
+
+const client = new Client()
+client.on('ready', () => {
+  const fs = createSshFs(client)
+  
+  // 列出目录
+  const files = await fs.list('/path/to/dir')
+  
+  // 读取文件
+  const content = await fs.readFile('/path/to/file.txt')
+  
+  // 写入文件
+  await fs.writeFile('/path/to/file.txt', 'Hello World')
+  
+  // 获取文件信息
+  const stat = await fs.stat('/path/to/file')
+  console.log(stat.isFile(), stat.isDirectory(), stat.size)
+  
+  // ... 更多操作
+})
+```
+
+## API
+
+### 构造函数
+
+```javascript
+createSshFs(client)
+```
+
+- `client` - 已认证的 ssh2 Client 实例
+
+### 方法
+
+#### 文件操作
+
+- `readFile(remotePath)` - 读取文件内容为字符串
+- `writeFile(remotePath, content, mode?)` - 写入字符串内容到文件
+- `readFileBase64(remotePath)` - 读取文件为 base64 编码字符串
+- `writeFileBase64(remotePath, base64Content)` - 写入 base64 内容到文件
+
+#### 目录操作
+
+- `list(remotePath)` - 列出目录内容
+- `mkdir(remotePath, options?)` - 创建目录
+- `rmdir(remotePath)` - 删除目录
+
+#### 文件/目录操作
+
+- `cp(from, to)` - 复制文件或目录
+- `mv(from, to)` - 移动/重命名文件或目录
+- `rename(oldPath, newPath)` - 重命名文件或目录
+- `rm(remotePath)` - 删除文件
+- `touch(remotePath)` - 创建空文件或更新时间戳
+
+#### 文件信息
+
+- `stat(remotePath)` - 获取文件信息（跟随符号链接）
+- `lstat(remotePath)` - 获取文件信息（不跟随符号链接）
+- `realpath(remotePath)` - 获取规范路径
+- `readlink(remotePath)` - 读取符号链接目标
+- `getFolderSize(folderPath)` - 获取文件夹大小和文件数量
+
+#### 权限
+
+- `chmod(remotePath, mode)` - 更改文件权限
+
+#### 工具
+
+- `getHomeDir()` - 获取主目录
+- `runExec(command)` - 执行原始 shell 命令
+
+## 文件传输
+
+```javascript
+import { Transfer } from 'ssh2-scp/transfer'
+
+const transfer = new Transfer(fs, {
+  type: 'download', // 或 'upload'
+  remotePath: '/远程/路径',
+  localPath: '/本地/路径',
+  chunkSize: 32768,
+  onProgress: (transferred, total) => {
+    console.log(`进度: ${transferred}/${total}`)
+  }
+})
+
+await transfer.startTransfer()
+```
+
+### 传输选项
+
+- `type` - 传输类型：`'download'`（下载）或 `'upload'`（上传）
+- `remotePath` - 远程文件/文件夹路径
+- `localPath` - 本地文件/文件夹路径
+- `chunkSize` - 传输块大小（默认：32768）
+- `onProgress` - 进度回调函数 `(transferred, total) => void`
+- `onData` - 数据回调函数 `(count) => void`
+
+## 许可证
+
+MIT

package/README.md

@@ -0,0 +1,126 @@
+# ssh2-scp
+
+Remote file system operations over SSH2 session without SFTP
+
+[中文](./README-CN.md)
+
+## Features
+
+- File operations via SSH2 shell/command session (no SFTP required)
+- Supports all common file system operations
+- Both ESM and CJS exports
+- TypeScript support
+
+## Install
+
+```bash
+npm install ssh2-scp
+```
+
+## Usage
+
+```javascript
+import { Client } from 'ssh2'
+import { createSshFs } from 'ssh2-scp'
+
+const client = new Client()
+client.on('ready', () => {
+  const fs = createSshFs(client)
+  
+  // List directory
+  const files = await fs.list('/path/to/dir')
+  
+  // Read file
+  const content = await fs.readFile('/path/to/file.txt')
+  
+  // Write file
+  await fs.writeFile('/path/to/file.txt', 'Hello World')
+  
+  // Get file stats
+  const stat = await fs.stat('/path/to/file')
+  console.log(stat.isFile(), stat.isDirectory(), stat.size)
+  
+  // ... and more
+})
+```
+
+## API
+
+### Constructor
+
+```javascript
+createSshFs(client)
+```
+
+- `client` - An authenticated ssh2 Client instance
+
+### Methods
+
+#### File Operations
+
+- `readFile(remotePath)` - Read file content as string
+- `writeFile(remotePath, content, mode?)` - Write string content to file
+- `readFileBase64(remotePath)` - Read file as base64 encoded string
+- `writeFileBase64(remotePath, base64Content)` - Write base64 content to file
+
+#### Directory Operations
+
+- `list(remotePath)` - List directory contents
+- `mkdir(remotePath, options?)` - Create directory
+- `rmdir(remotePath)` - Remove directory
+
+#### File/Directory Manipulation
+
+- `cp(from, to)` - Copy file or directory
+- `mv(from, to)` - Move/rename file or directory
+- `rename(oldPath, newPath)` - Rename file or directory
+- `rm(remotePath)` - Remove file
+- `touch(remotePath)` - Create empty file or update timestamp
+
+#### File Info
+
+- `stat(remotePath)` - Get file stats (follows symlinks)
+- `lstat(remotePath)` - Get file stats (does not follow symlinks)
+- `realpath(remotePath)` - Get canonical path
+- `readlink(remotePath)` - Read symlink target
+- `getFolderSize(folderPath)` - Get folder size and file count
+
+#### Permissions
+
+- `chmod(remotePath, mode)` - Change file permissions
+
+#### Utilities
+
+- `getHomeDir()` - Get home directory
+- `runExec(command)` - Execute raw shell command
+
+## Transfer
+
+```javascript
+import { Transfer } from 'ssh2-scp/transfer'
+
+const transfer = new Transfer(fs, {
+  type: 'download', // or 'upload'
+  remotePath: '/remote/path',
+  localPath: '/local/path',
+  chunkSize: 32768,
+  onProgress: (transferred, total) => {
+    console.log(`Progress: ${transferred}/${total}`)
+  }
+})
+
+await transfer.startTransfer()
+```
+
+### Transfer Options
+
+- `type` - Transfer type: `'download'` or `'upload'`
+- `remotePath` - Remote file/folder path
+- `localPath` - Local file/folder path
+- `chunkSize` - Chunk size for transfer (default: 32768)
+- `onProgress` - Progress callback `(transferred, total) => void`
+- `onData` - Data callback `(count) => void`
+
+## License
+
+MIT

package/dist/esm/ssh-fs.d.ts

@@ -0,0 +1,81 @@
+import { Client } from 'ssh2';
+
+export declare function createSshFs(session: Client, options?: SshFsOptions): SshFs;
+
+export declare interface FileInfo {
+    type: string;
+    name: string;
+    size: number;
+    modifyTime: number;
+    accessTime: number;
+    mode: number;
+    rights: {
+        user: string;
+        group: string;
+        other: string;
+    };
+    owner: number;
+    group: number;
+}
+
+export declare class SshFs {
+    private session;
+    constructor(session: Client, _options?: SshFsOptions);
+    private getExecOpts;
+    private getMonthIndex;
+    private runCmd;
+    private rmFolderCmd;
+    private rmCmd;
+    getHomeDir(): Promise<string>;
+    rmdir(remotePath: string): Promise<unknown>;
+    private removeDirectoryRecursively;
+    rmrf(remotePath: string): Promise<string>;
+    touch(remotePath: string): Promise<string>;
+    cp(from: string, to: string): Promise<unknown>;
+    mv(from: string, to: string): Promise<unknown>;
+    runExec(cmd: string): Promise<string>;
+    getFolderSize(folderPath: string): Promise<{
+        size: string;
+        count: number;
+    }>;
+    private listFiles;
+    list(remotePath: string): Promise<FileInfo[]>;
+    mkdir(remotePath: string, options?: {
+        mode?: number;
+    }): Promise<string>;
+    stat(remotePath: string): Promise<Stats>;
+    readlink(remotePath: string): Promise<string>;
+    realpath(remotePath: string): Promise<string>;
+    lstat(remotePath: string): Promise<Stats>;
+    chmod(remotePath: string, mode: number): Promise<string>;
+    rename(remotePath: string, remotePathNew: string): Promise<string>;
+    rmFolder(remotePath: string): Promise<string>;
+    rm(remotePath: string): Promise<string>;
+    readFile(remotePath: string, options?: {
+        chunkSize?: number;
+    }): Promise<Buffer>;
+    writeFile(remotePath: string, str: Buffer | string, mode?: number, _options?: {
+        chunkSize?: number;
+    }): Promise<void>;
+}
+
+export declare interface SshFsOptions {
+}
+
+export declare interface Stats {
+    isDirectory: () => boolean;
+    isFile: () => boolean;
+    isBlockDevice: () => boolean;
+    isCharacterDevice: () => boolean;
+    isSymbolicLink: () => boolean;
+    isFIFO: () => boolean;
+    isSocket: () => boolean;
+    size: number;
+    mode: number;
+    uid: number;
+    gid: number;
+    atime: number;
+    mtime: number;
+}
+
+export { }

package/dist/esm/ssh-fs.js

@@ -0,0 +1,324 @@
+class SshFs {
+  session;
+  constructor(session, _options) {
+    this.session = session;
+  }
+  getExecOpts() {
+    return {};
+  }
+  getMonthIndex(month) {
+    const months = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+    return months.indexOf(month);
+  }
+  runCmd(cmd, timeout = 3e4) {
+    return new Promise((resolve, reject) => {
+      let timeoutId;
+      const cleanup = () => {
+        if (timeoutId) clearTimeout(timeoutId);
+      };
+      timeoutId = setTimeout(() => {
+        cleanup();
+        reject(new Error(`Command timed out: ${cmd}`));
+      }, timeout);
+      this.session.exec(cmd, (err, stream) => {
+        cleanup();
+        if (err) {
+          reject(err);
+        } else {
+          let out = Buffer.from("");
+          stream.on("end", () => {
+            resolve(out.toString());
+          }).on("data", (data) => {
+            out = Buffer.concat([out, data]);
+          }).stderr.on("data", (data) => {
+            reject(data.toString());
+          });
+        }
+      });
+    });
+  }
+  rmFolderCmd(remotePath) {
+    return this.runCmd(`rmdir "${remotePath}"`);
+  }
+  rmCmd(remotePath) {
+    return this.runCmd(`rm "${remotePath}"`);
+  }
+  async getHomeDir() {
+    return this.realpath(".");
+  }
+  async rmdir(remotePath) {
+    try {
+      return await this.rmrf(remotePath);
+    } catch (err) {
+      console.error("rm -rf dir error", err);
+      return this.removeDirectoryRecursively(remotePath);
+    }
+  }
+  async removeDirectoryRecursively(remotePath) {
+    try {
+      const contents = await this.listFiles(remotePath);
+      for (const item of contents) {
+        if (item.name === "." || item.name === "..") continue;
+        const itemPath = `${remotePath}/${item.name}`;
+        if (item.type === "d") {
+          await this.removeDirectoryRecursively(itemPath);
+        } else {
+          await this.rmCmd(itemPath);
+        }
+      }
+      await this.rmFolderCmd(remotePath);
+    } catch (e) {
+    }
+  }
+  rmrf(remotePath) {
+    return this.runCmd(`rm -rf "${remotePath}"`);
+  }
+  touch(remotePath) {
+    return this.runCmd(`touch "${remotePath}"`);
+  }
+  cp(from, to) {
+    return new Promise((resolve, reject) => {
+      const cmd = `cp -r "${from}" "${to}"`;
+      this.session.exec(cmd, this.getExecOpts(), (err) => {
+        if (err) reject(err);
+        else resolve(1);
+      });
+    });
+  }
+  mv(from, to) {
+    return new Promise((resolve, reject) => {
+      const cmd = `mv "${from}" "${to}"`;
+      this.session.exec(cmd, this.getExecOpts(), (err) => {
+        if (err) reject(err);
+        else resolve(1);
+      });
+    });
+  }
+  runExec(cmd) {
+    return new Promise((resolve, reject) => {
+      this.session.exec(cmd, this.getExecOpts(), (err, stream) => {
+        if (err) {
+          reject(err);
+        } else {
+          let out = Buffer.from("");
+          stream.on("end", () => {
+            resolve(out.toString());
+          }).on("data", (data) => {
+            out = Buffer.concat([out, data]);
+          }).stderr.on("data", (data) => {
+            reject(data.toString());
+          });
+        }
+      });
+    });
+  }
+  async getFolderSize(folderPath) {
+    const output = await this.runExec(`du -sh "${folderPath}" && find "${folderPath}" -type f | wc -l`);
+    const lines = output.trim().split("\n");
+    const size = lines[0]?.split("	")[0] || "0";
+    const count = parseInt(lines[1] || "0", 10);
+    return { size, count };
+  }
+  async listFiles(remotePath) {
+    const output = await this.runCmd(`ls -la "${remotePath}"`);
+    const lines = output.trim().split("\n");
+    const result = [];
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i].trim();
+      if (!line || i === 0) continue;
+      const parts = line.split(/\s+/);
+      if (parts.length < 9) continue;
+      const name = parts.slice(8).join(" ");
+      if (name === "." || name === "..") continue;
+      const type = parts[0].charAt(0);
+      const mode = parseInt(parts[0].slice(1), 8);
+      const owner = parseInt(parts[2], 10);
+      const group = parseInt(parts[3], 10);
+      const size = parseInt(parts[4], 10);
+      const month = parts[5];
+      const day = parts[6];
+      const timeOrYear = parts[7];
+      let mtime = 0;
+      const now = /* @__PURE__ */ new Date();
+      const year = now.getFullYear();
+      if (timeOrYear.includes(":")) {
+        const [hour, minute] = timeOrYear.split(":").map(Number);
+        mtime = new Date(year, this.getMonthIndex(month), parseInt(day, 10), hour, minute).getTime();
+      } else {
+        mtime = new Date(parseInt(timeOrYear, 10), this.getMonthIndex(month), parseInt(day, 10)).getTime();
+      }
+      result.push({
+        type,
+        name,
+        size,
+        modifyTime: mtime,
+        accessTime: mtime,
+        mode,
+        rights: {
+          user: parts[0].substring(1, 4),
+          group: parts[0].substring(4, 7),
+          other: parts[0].substring(7, 10)
+        },
+        owner,
+        group
+      });
+    }
+    return result;
+  }
+  list(remotePath) {
+    return this.listFiles(remotePath);
+  }
+  async mkdir(remotePath, options = {}) {
+    const cmd = options.mode ? `mkdir -m ${options.mode.toString(8)} -p "${remotePath}"` : `mkdir -p "${remotePath}"`;
+    return this.runCmd(cmd);
+  }
+  async stat(remotePath) {
+    const isSymlink = await this.runCmd(`test -L "${remotePath}" && echo 1 || echo 0`).then((r) => r.trim() === "1");
+    const output = await this.runCmd(`stat -c '%s %h %u %g %Y %Y %a' "${remotePath}"`);
+    const parts = output.trim().split(/\s+/);
+    if (parts.length < 7) {
+      return {
+        size: 0,
+        mode: 0,
+        uid: 0,
+        gid: 0,
+        atime: 0,
+        mtime: 0,
+        isFile: () => false,
+        isDirectory: () => false,
+        isSymbolicLink: () => false,
+        isBlockDevice: () => false,
+        isCharacterDevice: () => false,
+        isFIFO: () => false,
+        isSocket: () => false
+      };
+    }
+    const [size, _nlink, uid, gid, atime, mtime, modeOct] = parts;
+    const mode = parseInt(modeOct, 8);
+    return {
+      size: parseInt(size, 10),
+      mode,
+      uid: parseInt(uid, 10),
+      gid: parseInt(gid, 10),
+      atime: parseInt(atime, 10) * 1e3,
+      mtime: parseInt(mtime, 10) * 1e3,
+      isFile: () => (mode & 61440) === 32768,
+      isDirectory: () => (mode & 61440) === 16384,
+      isSymbolicLink: () => isSymlink,
+      isBlockDevice: () => (mode & 61440) === 24576,
+      isCharacterDevice: () => (mode & 61440) === 8192,
+      isFIFO: () => (mode & 61440) === 4096,
+      isSocket: () => (mode & 61440) === 49152
+    };
+  }
+  readlink(remotePath) {
+    return this.runCmd(`readlink "${remotePath}"`).then((output) => output.trim());
+  }
+  realpath(remotePath) {
+    return this.runCmd(`realpath "${remotePath}"`).then((output) => output.trim());
+  }
+  async lstat(remotePath) {
+    const output = await this.runCmd(`ls -ld "${remotePath}"`);
+    const isSymlink = output.trim().startsWith("l");
+    const statOutput = await this.runCmd(`stat -c '%s %h %u %g %Y %Y %a' "${remotePath}"`);
+    const parts = statOutput.trim().split(/\s+/);
+    if (parts.length < 7) {
+      return {
+        size: 0,
+        mode: 0,
+        uid: 0,
+        gid: 0,
+        atime: 0,
+        mtime: 0,
+        isFile: () => false,
+        isDirectory: () => false,
+        isSymbolicLink: () => false,
+        isBlockDevice: () => false,
+        isCharacterDevice: () => false,
+        isFIFO: () => false,
+        isSocket: () => false
+      };
+    }
+    const [size, _nlink, uid, gid, atime, mtime, modeOct] = parts;
+    const mode = parseInt(modeOct, 8);
+    return {
+      size: parseInt(size, 10),
+      mode,
+      uid: parseInt(uid, 10),
+      gid: parseInt(gid, 10),
+      atime: parseInt(atime, 10) * 1e3,
+      mtime: parseInt(mtime, 10) * 1e3,
+      isFile: () => !isSymlink && (mode & 61440) === 32768,
+      isDirectory: () => !isSymlink && (mode & 61440) === 16384,
+      isSymbolicLink: () => isSymlink,
+      isBlockDevice: () => (mode & 61440) === 24576,
+      isCharacterDevice: () => (mode & 61440) === 8192,
+      isFIFO: () => (mode & 61440) === 4096,
+      isSocket: () => (mode & 61440) === 49152
+    };
+  }
+  chmod(remotePath, mode) {
+    return this.runCmd(`chmod ${mode.toString(8)} "${remotePath}"`);
+  }
+  rename(remotePath, remotePathNew) {
+    return this.runCmd(`mv "${remotePath}" "${remotePathNew}"`);
+  }
+  rmFolder(remotePath) {
+    return this.rmFolderCmd(remotePath);
+  }
+  rm(remotePath) {
+    return this.rmCmd(remotePath);
+  }
+  async readFile(remotePath, options) {
+    const chunkSize = options?.chunkSize ?? 64 * 1024;
+    const fileSizeOutput = await this.runCmd(`stat -c %s "${remotePath}"`);
+    const fileSize = parseInt(fileSizeOutput.trim(), 10);
+    if (fileSize <= chunkSize) {
+      const output = await this.runCmd(`cat "${remotePath}"`);
+      return Buffer.from(output, "binary");
+    }
+    const chunks = [];
+    for (let offset = 0; offset < fileSize; offset += chunkSize) {
+      const cmd = `dd if="${remotePath}" bs=1K skip=${Math.floor(offset / 1024)} count=${Math.ceil(chunkSize / 1024)} 2>/dev/null`;
+      const chunkOutput = await this.runCmd(cmd);
+      if (chunkOutput) {
+        chunks.push(Buffer.from(chunkOutput, "binary"));
+      }
+    }
+    return Buffer.concat(chunks);
+  }
+  async writeFile(remotePath, str, mode, _options) {
+    const data = typeof str === "string" ? Buffer.from(str) : str;
+    const sizeThreshold = 64 * 1024;
+    if (data.length <= sizeThreshold) {
+      const escapedContent = data.toString("binary").replace(/'/g, "'\\''");
+      const cmd = `printf '%s' '${escapedContent}' > "${remotePath}"`;
+      await this.runCmd(cmd);
+    } else {
+      const tempBase = `/tmp/ssh-fs-${Date.now()}`;
+      await this.runCmd(`mkdir -p "${tempBase}"`);
+      try {
+        const chunkSize = 64 * 1024;
+        for (let i = 0; i < data.length; i += chunkSize) {
+          const chunk = data.slice(i, i + chunkSize);
+          const chunkFile = `${tempBase}/c${Math.floor(i / chunkSize)}`;
+          const escapedChunk = chunk.toString("binary").replace(/'/g, "'\\''");
+          await this.runCmd(`printf '%s' '${escapedChunk}' > "${chunkFile}"`);
+        }
+        await this.runCmd(`cat ${tempBase}/c* > "${remotePath}"`);
+      } finally {
+        await this.runCmd(`rm -rf "${tempBase}"`);
+      }
+    }
+    if (mode) {
+      await this.runCmd(`chmod ${mode.toString(8)} "${remotePath}"`);
+    }
+  }
+}
+function createSshFs(session, options) {
+  return new SshFs(session, options);
+}
+export {
+  SshFs,
+  createSshFs
+};

package/dist/esm/transfer.d.ts

@@ -0,0 +1,116 @@
+import { Client } from 'ssh2';
+
+declare interface FileInfo {
+    type: string;
+    name: string;
+    size: number;
+    modifyTime: number;
+    accessTime: number;
+    mode: number;
+    rights: {
+        user: string;
+        group: string;
+        other: string;
+    };
+    owner: number;
+    group: number;
+}
+
+declare class SshFs {
+    private session;
+    constructor(session: Client, _options?: SshFsOptions);
+    private getExecOpts;
+    private getMonthIndex;
+    private runCmd;
+    private rmFolderCmd;
+    private rmCmd;
+    getHomeDir(): Promise<string>;
+    rmdir(remotePath: string): Promise<unknown>;
+    private removeDirectoryRecursively;
+    rmrf(remotePath: string): Promise<string>;
+    touch(remotePath: string): Promise<string>;
+    cp(from: string, to: string): Promise<unknown>;
+    mv(from: string, to: string): Promise<unknown>;
+    runExec(cmd: string): Promise<string>;
+    getFolderSize(folderPath: string): Promise<{
+        size: string;
+        count: number;
+    }>;
+    private listFiles;
+    list(remotePath: string): Promise<FileInfo[]>;
+    mkdir(remotePath: string, options?: {
+        mode?: number;
+    }): Promise<string>;
+    stat(remotePath: string): Promise<Stats>;
+    readlink(remotePath: string): Promise<string>;
+    realpath(remotePath: string): Promise<string>;
+    lstat(remotePath: string): Promise<Stats>;
+    chmod(remotePath: string, mode: number): Promise<string>;
+    rename(remotePath: string, remotePathNew: string): Promise<string>;
+    rmFolder(remotePath: string): Promise<string>;
+    rm(remotePath: string): Promise<string>;
+    readFile(remotePath: string, options?: {
+        chunkSize?: number;
+    }): Promise<Buffer>;
+    writeFile(remotePath: string, str: Buffer | string, mode?: number, _options?: {
+        chunkSize?: number;
+    }): Promise<void>;
+}
+
+declare interface SshFsOptions {
+}
+
+declare interface Stats {
+    isDirectory: () => boolean;
+    isFile: () => boolean;
+    isBlockDevice: () => boolean;
+    isCharacterDevice: () => boolean;
+    isSymbolicLink: () => boolean;
+    isFIFO: () => boolean;
+    isSocket: () => boolean;
+    size: number;
+    mode: number;
+    uid: number;
+    gid: number;
+    atime: number;
+    mtime: number;
+}
+
+export declare class Transfer {
+    private session;
+    private options;
+    private chunkSize;
+    private state;
+    private aborted;
+    constructor(sshFs: SshFs, options: TransferOptions);
+    startTransfer(): Promise<void>;
+    private getRemoteFileSize;
+    private runExec;
+    private download;
+    private upload;
+    pause(): void;
+    resume(): void;
+    getState(): TransferState;
+    destroy(): void;
+}
+
+export declare interface TransferOptions {
+    type: TransferType;
+    remotePath: string;
+    localPath: string;
+    chunkSize?: number;
+    onProgress?: (transferred: number, total: number) => void;
+    onData?: (count: number) => void;
+}
+
+export declare interface TransferState {
+    transferred: number;
+    total: number;
+    paused: boolean;
+    completed: boolean;
+    error?: Error;
+}
+
+export declare type TransferType = 'download' | 'upload';
+
+export { }

package/dist/esm/transfer.js

@@ -0,0 +1,133 @@
+import * as fs from "fs";
+import * as path from "path";
+class Transfer {
+  session;
+  options;
+  chunkSize;
+  state;
+  aborted = false;
+  constructor(sshFs, options) {
+    this.session = sshFs.session;
+    this.options = options;
+    this.chunkSize = options.chunkSize || 32768;
+    this.state = {
+      transferred: 0,
+      total: 0,
+      paused: false,
+      completed: false
+    };
+  }
+  async startTransfer() {
+    if (this.state.completed || this.state.error || this.aborted) {
+      return;
+    }
+    const isDownload = this.options.type === "download";
+    try {
+      if (isDownload) {
+        await this.download();
+      } else {
+        await this.upload();
+      }
+      this.state.completed = true;
+    } catch (err) {
+      this.state.error = err;
+      throw err;
+    }
+  }
+  async getRemoteFileSize(remotePath) {
+    const output = await this.runExec(`stat -c %s "${remotePath}" 2>/dev/null || stat -f %z "${remotePath}" 2>/dev/null`);
+    return parseInt(output.trim(), 10) || 0;
+  }
+  runExec(cmd, stdinData) {
+    return new Promise((resolve, reject) => {
+      this.session.exec(cmd, (err, stream) => {
+        if (err) {
+          return reject(err);
+        }
+        if (stdinData) {
+          stream.stdin.write(stdinData);
+          stream.stdin.end();
+        }
+        let out = Buffer.from("");
+        stream.on("close", () => {
+          resolve(out.toString());
+        }).on("data", (data) => {
+          out = Buffer.concat([out, data]);
+        }).stderr.on("data", (data) => {
+          console.error("stderr:", data.toString());
+        });
+      });
+    });
+  }
+  async download() {
+    const { remotePath, localPath, onProgress, onData } = this.options;
+    const dir = path.dirname(localPath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    this.state.total = await this.getRemoteFileSize(remotePath);
+    return new Promise((resolve, reject) => {
+      const cmd = `dd if="${remotePath}" bs=${this.chunkSize} 2>/dev/null`;
+      this.session.exec(cmd, (err, stream) => {
+        if (err) {
+          return reject(err);
+        }
+        const writeStream = fs.createWriteStream(localPath);
+        let localTransferred = 0;
+        stream.on("data", (data) => {
+          if (this.state.paused || this.aborted) {
+            return;
+          }
+          writeStream.write(data);
+          localTransferred += data.length;
+          this.state.transferred = localTransferred;
+          if (onProgress) {
+            onProgress(localTransferred, this.state.total);
+          }
+          if (onData) {
+            onData(data.length);
+          }
+        });
+        stream.on("close", () => {
+          writeStream.end(() => {
+            resolve();
+          });
+        });
+        stream.on("error", (err2) => {
+          this.state.error = err2;
+          writeStream.end();
+          reject(err2);
+        });
+      });
+    });
+  }
+  async upload() {
+    const { remotePath, localPath, onProgress, onData } = this.options;
+    const fileContent = fs.readFileSync(localPath);
+    this.state.total = fileContent.length;
+    await this.runExec(`dd of="${remotePath}" bs=${this.chunkSize} 2>/dev/null`, fileContent);
+    this.state.transferred = this.state.total;
+    if (onProgress) {
+      onProgress(this.state.total, this.state.total);
+    }
+    if (onData) {
+      onData(fileContent.length);
+    }
+    this.state.completed = true;
+  }
+  pause() {
+    this.state.paused = true;
+  }
+  resume() {
+    this.state.paused = false;
+  }
+  getState() {
+    return { ...this.state };
+  }
+  destroy() {
+    this.aborted = true;
+  }
+}
+export {
+  Transfer
+};

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "ssh2-scp",
+  "version": "1.0.1",
+  "description": "Remote file system operations over SSH2 session without SFTP",
+  "homepage": "https://github.com/electerm/ssh2-scp#readme",
+  "bugs": {
+    "url": "https://github.com/electerm/ssh2-scp/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/electerm/ssh2-scp.git"
+  },
+  "license": "MIT",
+  "author": "ZHAO Xudong <zxdong@gmail.com>",
+  "type": "module",
+  "main": "./dist/cjs/ssh-fs.js",
+  "module": "./dist/esm/ssh-fs.js",
+  "types": "./dist/esm/ssh-fs.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/esm/ssh-fs.js",
+      "require": "./dist/cjs/ssh-fs.js",
+      "types": "./dist/esm/ssh-fs.d.ts"
+    },
+    "./transfer": {
+      "import": "./dist/esm/transfer.js",
+      "require": "./dist/cjs/transfer.js",
+      "types": "./dist/esm/transfer.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "README-CN.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "vite build --config build/vite.config.ts",
+    "build:esm": "vite build --config build/vite.config.ts --outDir dist/esm",
+    "build:cjs": "vite build --config build/vite.config.cjs.ts --outDir dist/cjs",
+    "test": "node test/ssh2-fs.test.mjs && node test/transfer.test.mjs",
+    "lint": "echo \"Lint not configured\" && exit 0",
+    "typecheck": "tsc --noEmit"
+  },
+  "devDependencies": {
+    "@types/node": "^20.10.0",
+    "@types/ssh2": "^1.11.0",
+    "@types/tar": "^6.1.0",
+    "ssh2": "^1.15.0",
+    "tar": "^6.2.0",
+    "typescript": "^5.3.0",
+    "vite": "^5.0.0",
+    "vite-plugin-dts": "^3.6.0"
+  },
+  "engines": {
+    "node": ">=22.0.0"
+  }
+}