@zero-transfer/sdk 0.1.0-alpha.0 → 0.1.2

package/dist/index.mjs

@@ -2440,6 +2440,74 @@ var FtpFileSystem = class {
       path: remotePath
     };
   }
+  async remove(path2, options = {}) {
+    const remotePath = normalizeFtpPath(path2);
+    const response = await this.control.sendCommand(`DELE ${remotePath}`);
+    if (response.completion) return;
+    if (response.code === 550 && options.ignoreMissing) return;
+    assertPathCommandSucceeded(response, "DELE", remotePath, this.control.providerId);
+  }
+  async rename(from, to) {
+    const fromPath = normalizeFtpPath(from);
+    const toPath = normalizeFtpPath(to);
+    const rnfr = await this.control.sendCommand(`RNFR ${fromPath}`);
+    if (!rnfr.intermediate && !rnfr.completion) {
+      assertPathCommandSucceeded(rnfr, "RNFR", fromPath, this.control.providerId);
+    }
+    await expectCompletion(this.control, `RNTO ${toPath}`, toPath);
+  }
+  async mkdir(path2, options = {}) {
+    const remotePath = normalizeFtpPath(path2);
+    if (!options.recursive) {
+      await expectCompletion(this.control, `MKD ${remotePath}`, remotePath);
+      return;
+    }
+    const segments = remotePath.split("/").filter((s) => s.length > 0);
+    let current = "";
+    for (const segment of segments) {
+      current = `${current}/${segment}`;
+      const response = await this.control.sendCommand(`MKD ${current}`);
+      if (response.completion) continue;
+      if (response.code === 550) continue;
+      assertPathCommandSucceeded(response, "MKD", current, this.control.providerId);
+    }
+  }
+  async rmdir(path2, options = {}) {
+    const remotePath = normalizeFtpPath(path2);
+    if (options.recursive) {
+      await this.removeDirectoryRecursive(remotePath);
+      return;
+    }
+    const response = await this.control.sendCommand(`RMD ${remotePath}`);
+    if (response.completion) return;
+    if (response.code === 550 && options.ignoreMissing) return;
+    assertPathCommandSucceeded(response, "RMD", remotePath, this.control.providerId);
+  }
+  async removeDirectoryRecursive(remotePath) {
+    let entries;
+    try {
+      entries = await readDirectoryEntries(this.control, remotePath);
+    } catch (error) {
+      if (error instanceof PathNotFoundError) return;
+      throw error;
+    }
+    for (const entry of entries) {
+      if (entry.name === "." || entry.name === "..") continue;
+      const childPath = entry.path.startsWith("/") ? entry.path : normalizeFtpPath(`${remotePath.replace(/\/+$/, "")}/${entry.name}`);
+      if (entry.type === "directory") {
+        await this.removeDirectoryRecursive(childPath);
+      } else {
+        const del = await this.control.sendCommand(`DELE ${childPath}`);
+        if (!del.completion && del.code !== 550) {
+          assertPathCommandSucceeded(del, "DELE", childPath, this.control.providerId);
+        }
+      }
+    }
+    const response = await this.control.sendCommand(`RMD ${remotePath}`);
+    if (response.completion) return;
+    if (response.code === 550) return;
+    assertPathCommandSucceeded(response, "RMD", remotePath, this.control.providerId);
+  }
 };
 var FtpControlConnection = class _FtpControlConnection {
   /**
@@ -3473,7 +3541,8 @@ function normalizeFeatureLines(input) {
 // src/providers/classic/sftp/SftpProvider.ts
 import { Buffer as Buffer5 } from "buffer";
 import { createHash, createHmac, timingSafeEqual } from "crypto";
-import { Client, utils } from "ssh2";
+import ssh2 from "ssh2";
+var { Client: SshClientCtor, utils } = ssh2;
 var SFTP_PROVIDER_ID = "sftp";
 var SFTP_DEFAULT_PORT = 22;
 var SFTP_PROVIDER_CAPABILITIES = {
@@ -3631,9 +3700,104 @@ var SftpFileSystem = class {
       throw mapSftpError(error, { command: "LSTAT", path: remotePath });
     }
   }
+  async remove(path2, options = {}) {
+    throwIfAborted2(options.signal, path2, "remove");
+    const remotePath = normalizeSftpPath(path2);
+    try {
+      await sftpUnlink(this.sftp, remotePath);
+    } catch (error) {
+      const mapped = mapSftpError(error, { command: "REMOVE", path: remotePath });
+      if (options.ignoreMissing && mapped instanceof PathNotFoundError) return;
+      throw mapped;
+    }
+  }
+  async rename(from, to, options = {}) {
+    throwIfAborted2(options.signal, from, "rename");
+    const fromPath = normalizeSftpPath(from);
+    const toPath = normalizeSftpPath(to);
+    try {
+      await sftpRename(this.sftp, fromPath, toPath);
+    } catch (error) {
+      throw mapSftpError(error, { command: "RENAME", path: fromPath });
+    }
+  }
+  async mkdir(path2, options = {}) {
+    throwIfAborted2(options.signal, path2, "mkdir");
+    const remotePath = normalizeSftpPath(path2);
+    if (!options.recursive) {
+      try {
+        await sftpMkdir(this.sftp, remotePath);
+      } catch (error) {
+        throw mapSftpError(error, { command: "MKDIR", path: remotePath });
+      }
+      return;
+    }
+    const segments = remotePath.split("/").filter((s) => s.length > 0);
+    let current = "";
+    for (const segment of segments) {
+      current = `${current}/${segment}`;
+      try {
+        await sftpMkdir(this.sftp, current);
+      } catch (error) {
+        try {
+          const stats = await readSftpStats(this.sftp, current);
+          if (stats.isDirectory()) continue;
+        } catch {
+        }
+        throw mapSftpError(error, { command: "MKDIR", path: current });
+      }
+    }
+  }
+  async rmdir(path2, options = {}) {
+    throwIfAborted2(options.signal, path2, "rmdir");
+    const remotePath = normalizeSftpPath(path2);
+    if (options.recursive) {
+      await this.removeDirectoryRecursive(remotePath);
+      return;
+    }
+    try {
+      await sftpRmdir(this.sftp, remotePath);
+    } catch (error) {
+      const mapped = mapSftpError(error, { command: "RMDIR", path: remotePath });
+      if (options.ignoreMissing && mapped instanceof PathNotFoundError) return;
+      throw mapped;
+    }
+  }
+  async removeDirectoryRecursive(remotePath) {
+    let entries;
+    try {
+      entries = await readSftpDirectory(this.sftp, remotePath);
+    } catch (error) {
+      const mapped = mapSftpError(error, { command: "READDIR", path: remotePath });
+      if (mapped instanceof PathNotFoundError) return;
+      throw mapped;
+    }
+    for (const entry of entries) {
+      if (entry.filename === "." || entry.filename === "..") continue;
+      const childPath = `${remotePath.replace(/\/+$/, "")}/${entry.filename}`.replace(/\/+/g, "/");
+      const isDir = entry.attrs.isDirectory();
+      try {
+        if (isDir) {
+          await this.removeDirectoryRecursive(childPath);
+        } else {
+          await sftpUnlink(this.sftp, childPath);
+        }
+      } catch (error) {
+        throw mapSftpError(error, {
+          command: isDir ? "RMDIR" : "REMOVE",
+          path: childPath
+        });
+      }
+    }
+    try {
+      await sftpRmdir(this.sftp, remotePath);
+    } catch (error) {
+      throw mapSftpError(error, { command: "RMDIR", path: remotePath });
+    }
+  }
 };
 async function connectSshClient(profile, options, username, authentication) {
-  const client = new Client();
+  const client = new SshClientCtor();
   let config;
   try {
     config = await createConnectConfig(profile, options, username, authentication);
@@ -4022,6 +4186,50 @@ function readSftpStats(sftp, path2) {
     });
   });
 }
+function sftpUnlink(sftp, path2) {
+  return new Promise((resolve, reject) => {
+    sftp.unlink(path2, (error) => {
+      if (error !== void 0 && error !== null) {
+        reject(error);
+        return;
+      }
+      resolve();
+    });
+  });
+}
+function sftpRename(sftp, from, to) {
+  return new Promise((resolve, reject) => {
+    sftp.rename(from, to, (error) => {
+      if (error !== void 0 && error !== null) {
+        reject(error);
+        return;
+      }
+      resolve();
+    });
+  });
+}
+function sftpMkdir(sftp, path2) {
+  return new Promise((resolve, reject) => {
+    sftp.mkdir(path2, (error) => {
+      if (error !== void 0 && error !== null) {
+        reject(error);
+        return;
+      }
+      resolve();
+    });
+  });
+}
+function sftpRmdir(sftp, path2) {
+  return new Promise((resolve, reject) => {
+    sftp.rmdir(path2, (error) => {
+      if (error !== void 0 && error !== null) {
+        reject(error);
+        return;
+      }
+      resolve();
+    });
+  });
+}
 async function* createSftpReadSource(sftp, path2, range, request) {
   if (range.length <= 0) {
     return;
@@ -4349,7 +4557,8 @@ function noop() {
 
 // src/providers/classic/sftp/jumpHost.ts
 import { Buffer as Buffer6 } from "buffer";
-import { Client as SshClient } from "ssh2";
+import ssh22 from "ssh2";
+var { Client: SshClientCtor2 } = ssh22;
 function createSftpJumpHostSocketFactory(options) {
   if (options.bastion === void 0 && options.buildBastion === void 0) {
     throw new ConfigurationError({
@@ -4370,7 +4579,7 @@ function createSftpJumpHostSocketFactory(options) {
 }
 function openJumpHostChannel(options) {
   const { bastionConfig, context } = options;
-  const client = options.createClient ? options.createClient() : new SshClient();
+  const client = options.createClient ? options.createClient() : new SshClientCtor2();
   if (context.signal?.aborted === true) {
     return Promise.reject(
       new AbortError({
@@ -6730,7 +6939,17 @@ async function collectChunks5(source) {
 
 // src/providers/local/LocalProvider.ts
 import { createReadStream } from "fs";
-import { lstat, mkdir, open, readdir, readlink, writeFile } from "fs/promises";
+import {
+  lstat,
+  mkdir,
+  open,
+  readdir,
+  readlink,
+  rename,
+  rm,
+  unlink,
+  writeFile
+} from "fs/promises";
 import path from "path";
 var LOCAL_PROVIDER_ID = "local";
 var LOCAL_PROVIDER_CAPABILITIES = {
@@ -6856,7 +7075,55 @@ var LocalFileSystem = class {
   async stat(path2) {
     return readLocalEntry(this.rootPath, normalizeLocalProviderPath(path2));
   }
+  async remove(remote, options = {}) {
+    const remotePath = normalizeLocalProviderPath(remote);
+    const localPath = resolveLocalPath(this.rootPath, remotePath);
+    try {
+      await unlink(localPath);
+    } catch (error) {
+      if (options.ignoreMissing && isNodeErrno(error, "ENOENT")) return;
+      if (isNodeErrno(error, "ENOENT")) {
+        throw createPathNotFoundError(remotePath, `Local path not found: ${remotePath}`);
+      }
+      throw error;
+    }
+  }
+  async rename(from, to) {
+    const fromRemote = normalizeLocalProviderPath(from);
+    const toRemote = normalizeLocalProviderPath(to);
+    const fromLocal = resolveLocalPath(this.rootPath, fromRemote);
+    const toLocal = resolveLocalPath(this.rootPath, toRemote);
+    try {
+      await rename(fromLocal, toLocal);
+    } catch (error) {
+      if (isNodeErrno(error, "ENOENT")) {
+        throw createPathNotFoundError(fromRemote, `Local path not found: ${fromRemote}`);
+      }
+      throw error;
+    }
+  }
+  async mkdir(remote, options = {}) {
+    const remotePath = normalizeLocalProviderPath(remote);
+    const localPath = resolveLocalPath(this.rootPath, remotePath);
+    await mkdir(localPath, { recursive: options.recursive === true });
+  }
+  async rmdir(remote, options = {}) {
+    const remotePath = normalizeLocalProviderPath(remote);
+    const localPath = resolveLocalPath(this.rootPath, remotePath);
+    try {
+      await rm(localPath, { recursive: options.recursive === true, force: false });
+    } catch (error) {
+      if (isNodeErrno(error, "ENOENT")) {
+        if (options.ignoreMissing) return;
+        throw createPathNotFoundError(remotePath, `Local path not found: ${remotePath}`);
+      }
+      throw error;
+    }
+  }
 };
+function isNodeErrno(error, code) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === code;
+}
 function resolveReadRange2(size, range) {
   if (range === void 0) {
     return { length: size, offset: 0 };
@@ -7019,6 +7286,11 @@ function normalizeLocalProviderPath(input) {
 }
 function resolveLocalPath(rootPath, remotePath) {
   const normalizedRemotePath = normalizeLocalProviderPath(remotePath);
+  const resolvedRootPath = path.resolve(rootPath);
+  const candidateAbsolute = path.resolve(normalizedRemotePath.split("/").join(path.sep));
+  if (candidateAbsolute === resolvedRootPath || candidateAbsolute.startsWith(resolvedRootPath + path.sep)) {
+    return candidateAbsolute;
+  }
   const relativePath = normalizedRemotePath === "/" ? "." : normalizedRemotePath.slice(1);
   const resolvedPath = path.resolve(rootPath, relativePath.split("/").join(path.sep));
   const relativeToRoot = path.relative(rootPath, resolvedPath);
@@ -7170,6 +7442,96 @@ var MemoryFileSystem = class {
       () => cloneRemoteStat(this.requireEntry(normalizeMemoryPath(path2)))
     );
   }
+  remove(path2, options = {}) {
+    return Promise.resolve().then(() => {
+      const normalized = normalizeMemoryPath(path2);
+      const entry = this.state.entries.get(normalized);
+      if (entry === void 0) {
+        if (options.ignoreMissing) return;
+        throw createPathNotFoundError2(normalized, `Memory path not found: ${normalized}`);
+      }
+      if (entry.type === "directory") {
+        throw createPathNotFoundError2(
+          normalized,
+          `Memory path is a directory; use rmdir: ${normalized}`
+        );
+      }
+      this.state.entries.delete(normalized);
+      this.state.content.delete(normalized);
+    });
+  }
+  rename(from, to) {
+    return Promise.resolve().then(() => {
+      const fromPath = normalizeMemoryPath(from);
+      const toPath = normalizeMemoryPath(to);
+      const entry = this.state.entries.get(fromPath);
+      if (entry === void 0) {
+        throw createPathNotFoundError2(fromPath, `Memory path not found: ${fromPath}`);
+      }
+      ensureParentDirectories(this.state.entries, toPath);
+      const moved = { ...entry, path: toPath, name: basenameRemotePath(toPath) };
+      this.state.entries.delete(fromPath);
+      this.state.entries.set(toPath, moved);
+      const content = this.state.content.get(fromPath);
+      if (content !== void 0) {
+        this.state.content.delete(fromPath);
+        this.state.content.set(toPath, content);
+      }
+    });
+  }
+  mkdir(path2, options = {}) {
+    return Promise.resolve().then(() => {
+      const normalized = normalizeMemoryPath(path2);
+      const existing = this.state.entries.get(normalized);
+      if (existing !== void 0) {
+        if (existing.type === "directory" && options.recursive) return;
+        throw createInvalidFixtureError(normalized, `Memory path already exists: ${normalized}`);
+      }
+      if (options.recursive) {
+        ensureParentDirectories(this.state.entries, normalized);
+      } else {
+        const parent = getParentPath2(normalized);
+        if (parent !== void 0 && !this.state.entries.has(parent)) {
+          throw createPathNotFoundError2(parent, `Memory parent not found: ${parent}`);
+        }
+      }
+      this.state.entries.set(normalized, createDirectoryEntry(normalized));
+    });
+  }
+  rmdir(path2, options = {}) {
+    return Promise.resolve().then(() => {
+      const normalized = normalizeMemoryPath(path2);
+      const entry = this.state.entries.get(normalized);
+      if (entry === void 0) {
+        if (options.ignoreMissing) return;
+        throw createPathNotFoundError2(normalized, `Memory path not found: ${normalized}`);
+      }
+      if (entry.type !== "directory") {
+        throw createPathNotFoundError2(normalized, `Memory path is not a directory: ${normalized}`);
+      }
+      const children = [...this.state.entries.values()].filter(
+        (child) => child.path !== normalized && getParentPath2(child.path) === normalized
+      );
+      if (children.length > 0 && !options.recursive) {
+        throw createInvalidFixtureError(normalized, `Memory directory not empty: ${normalized}`);
+      }
+      const stack = [...children];
+      while (stack.length > 0) {
+        const next = stack.pop();
+        if (!next) continue;
+        if (next.type === "directory") {
+          for (const grand of this.state.entries.values()) {
+            if (grand.path !== next.path && getParentPath2(grand.path) === next.path) {
+              stack.push(grand);
+            }
+          }
+        }
+        this.state.entries.delete(next.path);
+        this.state.content.delete(next.path);
+      }
+      this.state.entries.delete(normalized);
+    });
+  }
   requireEntry(path2) {
     const entry = this.state.entries.get(path2);
     if (entry === void 0) {