ssh2-scp 1.0.1 → 1.0.2

package/dist/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/dist/cjs/ssh-fs.cjs

@@ -0,0 +1,324 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+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);
+}
+exports.SshFs = SshFs;
+exports.createSshFs = createSshFs;

package/dist/cjs/transfer.cjs

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const fs = require("fs");
+const path = require("path");
+function _interopNamespaceDefault(e) {
+  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
+  if (e) {
+    for (const k in e) {
+      if (k !== "default") {
+        const d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: () => e[k]
+        });
+      }
+    }
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+const fs__namespace = /* @__PURE__ */ _interopNamespaceDefault(fs);
+const path__namespace = /* @__PURE__ */ _interopNamespaceDefault(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__namespace.dirname(localPath);
+    if (!fs__namespace.existsSync(dir)) {
+      fs__namespace.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__namespace.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__namespace.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;
+  }
+}
+exports.Transfer = Transfer;

package/package.json

@@ -1,7 +1,15 @@
 {
   "name": "ssh2-scp",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "Remote file system operations over SSH2 session without SFTP",
+  "scripts": {
+    "build": "npm run build:esm && npm run build:cjs",
+    "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"
+  },
   "homepage": "https://github.com/electerm/ssh2-scp#readme",
   "bugs": {
     "url": "https://github.com/electerm/ssh2-scp/issues"
@@ -19,12 +27,12 @@
   "exports": {
     ".": {
       "import": "./dist/esm/ssh-fs.js",
-      "require": "./dist/cjs/ssh-fs.js",
+      "require": "./dist/cjs/ssh-fs.cjs",
       "types": "./dist/esm/ssh-fs.d.ts"
     },
     "./transfer": {
       "import": "./dist/esm/transfer.js",
-      "require": "./dist/cjs/transfer.js",
+      "require": "./dist/cjs/transfer.cjs",
       "types": "./dist/esm/transfer.d.ts"
     }
   },
@@ -34,14 +42,6 @@
     "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",