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

package/dist/index.cjs

@@ -2601,6 +2601,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 {
   /**
@@ -3634,7 +3702,8 @@ function normalizeFeatureLines(input) {
 // src/providers/classic/sftp/SftpProvider.ts
 var import_node_buffer4 = require("buffer");
 var import_node_crypto = require("crypto");
-var import_ssh2 = require("ssh2");
+var import_ssh2 = __toESM(require("ssh2"));
+var { Client: SshClientCtor, utils } = import_ssh2.default;
 var SFTP_PROVIDER_ID = "sftp";
 var SFTP_DEFAULT_PORT = 22;
 var SFTP_PROVIDER_CAPABILITIES = {
@@ -3792,9 +3861,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 import_ssh2.Client();
+  const client = new SshClientCtor();
   let config;
   try {
     config = await createConnectConfig(profile, options, username, authentication);
@@ -3993,7 +4157,7 @@ function parseKnownHostsLine(line, lineNumber) {
   };
 }
 function parseKnownHostPublicKey(value, lineNumber) {
-  const parsed = import_ssh2.utils.parseKey(value);
+  const parsed = utils.parseKey(value);
   if (parsed instanceof Error) {
     throw createKnownHostsConfigurationError(lineNumber, parsed.message);
   }
@@ -4183,6 +4347,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;
@@ -4510,7 +4718,8 @@ function noop() {
 
 // src/providers/classic/sftp/jumpHost.ts
 var import_node_buffer5 = require("buffer");
-var import_ssh22 = require("ssh2");
+var import_ssh22 = __toESM(require("ssh2"));
+var { Client: SshClientCtor2 } = import_ssh22.default;
 function createSftpJumpHostSocketFactory(options) {
   if (options.bastion === void 0 && options.buildBastion === void 0) {
     throw new ConfigurationError({
@@ -4531,7 +4740,7 @@ function createSftpJumpHostSocketFactory(options) {
 }
 function openJumpHostChannel(options) {
   const { bastionConfig, context } = options;
-  const client = options.createClient ? options.createClient() : new import_ssh22.Client();
+  const client = options.createClient ? options.createClient() : new SshClientCtor2();
   if (context.signal?.aborted === true) {
     return Promise.reject(
       new AbortError({
@@ -7017,7 +7226,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 (0, import_promises2.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 (0, import_promises2.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 (0, import_promises2.mkdir)(localPath, { recursive: options.recursive === true });
+  }
+  async rmdir(remote, options = {}) {
+    const remotePath = normalizeLocalProviderPath(remote);
+    const localPath = resolveLocalPath(this.rootPath, remotePath);
+    try {
+      await (0, import_promises2.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 };
@@ -7180,6 +7437,11 @@ function normalizeLocalProviderPath(input) {
 }
 function resolveLocalPath(rootPath, remotePath) {
   const normalizedRemotePath = normalizeLocalProviderPath(remotePath);
+  const resolvedRootPath = import_node_path2.default.resolve(rootPath);
+  const candidateAbsolute = import_node_path2.default.resolve(normalizedRemotePath.split("/").join(import_node_path2.default.sep));
+  if (candidateAbsolute === resolvedRootPath || candidateAbsolute.startsWith(resolvedRootPath + import_node_path2.default.sep)) {
+    return candidateAbsolute;
+  }
   const relativePath = normalizedRemotePath === "/" ? "." : normalizedRemotePath.slice(1);
   const resolvedPath = import_node_path2.default.resolve(rootPath, relativePath.split("/").join(import_node_path2.default.sep));
   const relativeToRoot = import_node_path2.default.relative(rootPath, resolvedPath);
@@ -7331,6 +7593,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) {