@dnax/core 0.77.9 → 0.78.1

package/lib/media/sftp.ts

@@ -1,116 +1,699 @@
-import { Client } from "ssh2";
-import type { SFTPWrapper } from "ssh2";
-import { consola } from "consola";
+import { $ } from "bun";
+import { join } from "path";
+import { tmpdir } from "os";
 import path from "path";
 import chokidar from "chokidar";
 import fs from "fs-extra";
 import type { Collection } from "../../types";
+import consola from "consola";
 const BASE_DIR = "/uploads/";
-type ConfigType = {
-  host: string;
-  port?: number;
-  username: string;
-  password: string;
-  remoteDir: string;
-  path?: string;
-  ignorePatterns?: string[];
-  //privateKeyPath?: string;
-};
-class FilesystemSftpAdapter {
-  conn: Client;
-  type: "sftp";
-  config: ConfigType;
-  constructor(
-    config = {
-      port: 22,
-    } as ConfigType
-  ) {
-    this.config = config;
-    this.type = "sftp";
-    this.conn = new Client({
-      captureRejections: true,
-      //captureRejections: true,
-    });
-
-    this.connect()
-      .then((e) => {
-        e.conn.end();
-      })
-      .catch((err) => {
-        consola.error(`SFTP: Failed to connect ${this.config.host}`.red);
-      });
-    // this.conn.
-    return this;
-  }
 
-  async syncCollectionMedia(col: Collection) {
-    if (!this.config?.remoteDir) this.config.remoteDir = "/home/" + col?.slug;
-
-    let visibility = col?.media?.visibility || "public";
-    let dirToWatch = path.join(process.cwd(), BASE_DIR, col?.slug, visibility);
-    dirToWatch = path.resolve(dirToWatch);
-    const watcher = chokidar.watch(dirToWatch, {
-      persistent: true,
-      ignoreInitial: true,
-      ignored: this.config.ignorePatterns || [],
-    });
-
-    watcher.on("all", (event, filePath) => {
-      if (event == "change" || event == "add") {
-        //consola.info(`SFTP: ${event} ${filePath}`);
-        let remotePath = path.join(
-          this.config.remoteDir,
-          path.basename(filePath)
+// ============================================================================
+// EXPECT DEPENDENCY CHECK
+// ============================================================================
+
+function getExpectInstallMessage(): string {
+    return [
+        "Linux (Debian/Ubuntu) : sudo apt-get install expect",
+        "Linux (RHEL/CentOS)    : sudo yum install expect",
+        "Linux (Fedora)         : sudo dnf install expect",
+        "macOS                  : brew install expect",
+        "Windows (Chocolatey)   : choco install expect",
+        "Windows (autrement)    : utilisez WSL ou Cygwin pour avoir expect.",
+    ].join("\n");
+}
+
+async function checkExpectInstalled(): Promise<void> {
+    try {
+        await $`expect -c "exit 0"`.quiet();
+    } catch {
+        const instructions = getExpectInstallMessage();
+        throw new Error(
+            `La commande "expect" n'est pas installée sur cette machine. Elle est requise pour l'authentification par mot de passe SFTP/SSH.\n\n` +
+            `Installation : ${instructions}`
         );
-        this.put(filePath, remotePath);
-      }
-    });
-  }
+    }
+}
+
+// ============================================================================
+// TYPES & INTERFACES
+// ============================================================================
+
+interface SftpConfig {
+    host: string;
+    user: string;
+    username?: string;
+    port?: number;
+    password?: string;
+    identityFile?: string;
+    remoteDir?: string;
+    ignorePatterns?: string[];
+}
+
+interface FileInfo {
+    name: string;
+    size: number;
+    isDirectory: boolean;
+    modified: Date;
+    permissions: string;
+}
+
+interface UploadOptions {
+    onProgress?: (percent: number) => void;
+    overwrite?: boolean;
+}
+
+interface DownloadOptions {
+    onProgress?: (percent: number) => void;
+}
+
+// ============================================================================
+// FILESYSTEM SFTP ADAPTER
+// ============================================================================
+
+class FilesystemSftpAdapter {
+    private config: SftpConfig;
+    private connected: boolean = false;
+    private remoteDir: string;
+    private ignorePatterns: string[];
+    type: "sftp";
+
+    constructor(config: SftpConfig) {
+        this.type = "sftp";
+        if (!config.username) config.username = "root";
+        config.user = config.username;
+        this.config = config;
+        this.remoteDir = config.remoteDir || "/";
+        this.ignorePatterns = config.ignorePatterns || [];
+        this.connect()
+    }
 
-  connect(): Promise<{ sftp: SFTPWrapper; conn: Client }> {
-    return new Promise((resolve, reject) => {
-      this.conn
-        .on("ready", () => {
-          this.conn.sftp((err, sftp) => {
-            if (err) {
-              this.conn.end();
-              return reject(err?.message);
+    // --------------------------------------------------------------------------
+    // PRIVATE HELPERS
+    // --------------------------------------------------------------------------
+
+    private get destination(): string {
+        return `${this.config.user}@${this.config.host}`;
+    }
+
+    private resolvePath(remotePath: string): string {
+        if (remotePath.startsWith("/")) {
+            return remotePath;
+        }
+        return join(this.remoteDir, remotePath).replace(/\\/g, "/");
+    }
+
+    private shouldIgnore(filePath: string): boolean {
+        if (this.ignorePatterns.length === 0) return false;
+
+        const fileName = filePath.split("/").pop() || filePath;
+
+        for (const pattern of this.ignorePatterns) {
+            // Support glob patterns: *, **, ?
+            const regexPattern = pattern
+                .replace(/\./g, "\\.")
+                .replace(/\*\*/g, "{{DOUBLE_STAR}}")
+                .replace(/\*/g, "[^/]*")
+                .replace(/{{DOUBLE_STAR}}/g, ".*")
+                .replace(/\?/g, ".");
+
+            const regex = new RegExp(`^${regexPattern}$`);
+
+            if (regex.test(fileName) || regex.test(filePath)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    private async getLocalFiles(localDir: string, baseDir = ""): Promise<string[]> {
+        const files: string[] = [];
+        const entries = await $`ls -1 ${localDir}`.quiet().text();
+
+        for (const entry of entries.trim().split("\n").filter(Boolean)) {
+            const fullPath = join(localDir, entry);
+            const relativePath = baseDir ? `${baseDir}/${entry}` : entry;
+
+            if (this.shouldIgnore(relativePath) || this.shouldIgnore(entry)) {
+                continue;
+            }
+
+            const isDir = await $`test -d ${fullPath} && echo yes || echo no`.quiet().text();
+
+            if (isDir.trim() === "yes") {
+                const subFiles = await this.getLocalFiles(fullPath, relativePath);
+                files.push(...subFiles);
+            } else {
+                files.push(relativePath);
             }
-            resolve({
-              sftp: sftp,
-              conn: this.conn,
-            });
-          });
-        })
-        .on("error", (err) => reject(err?.message))
-        .connect(this.config);
-    });
+        }
+
+        return files;
+    }
+
+    private get portArg(): string {
+        return this.config.port ? `-P ${this.config.port}` : "";
+    }
+
+    private get sshPortArg(): string {
+        return this.config.port ? `-p ${this.config.port}` : "";
+    }
+
+    private get identityArg(): string {
+        if (!this.config.identityFile) return "";
+        const keyPath = this.config.identityFile.replace("~", process.env.HOME || "");
+        return `-i ${keyPath}`;
+    }
+
+    private async execWithPassword(command: string): Promise<string> {
+        const { password } = this.config;
+
+        if (!password) {
+            const result = await $`sh -c ${command}`.quiet();
+            return result.text();
+        }
+
+        await checkExpectInstalled();
+
+        const expectScript = `
+set timeout 30
+spawn sh -c "${command.replace(/"/g, '\\"')}"
+expect {
+  "password:" {
+    send "${password}\\r"
+    exp_continue
+  }
+  "Password:" {
+    send "${password}\\r"
+    exp_continue
   }
-  async put(localPath: string, remotePath: string) {
-    let { sftp, conn } = await this.connect();
-    return new Promise(async (resolve, reject) => {
-      sftp.fastPut(
-        localPath,
-        remotePath,
-        {
-        
-          mode: 0o777,
-          // concurrency
-        },
-        (err: any) => {
-          conn.end();
-          if (err) {
-            console.error(err?.message || err);
-          }
-          if (err) {
-            reject(err?.message);
-          }
-
-          resolve(true);
-        }
-      );
-    });
+  "yes/no" {
+    send "yes\\r"
+    exp_continue
   }
+  eof
+}
+catch wait result
+exit [lindex $result 3]
+`;
+
+        const scriptFile = join(tmpdir(), `expect-${Date.now()}.exp`);
+        await Bun.write(scriptFile, expectScript);
+
+        try {
+            const result = await $`expect ${scriptFile}`.quiet();
+            return result.text();
+        } finally {
+            await $`rm -f ${scriptFile}`.quiet().nothrow();
+        }
+    }
+
+    private async sshExec(command: string): Promise<string> {
+        const cmd = `ssh ${this.identityArg} ${this.sshPortArg} -o StrictHostKeyChecking=accept-new ${this.destination} ${command}`;
+        return await this.execWithPassword(cmd);
+    }
+
+    private cleanOutput(output: string): string[] {
+        return output
+            .split("\n")
+            .filter((line) => {
+                const lower = line.toLowerCase();
+                return (
+                    line.trim() &&
+                    !lower.includes("password") &&
+                    !lower.includes("spawn") &&
+                    !lower.includes("expect")
+                );
+            })
+            .map((line) => line.trim());
+    }
+
+    // --------------------------------------------------------------------------
+    // CONNECTION
+    // --------------------------------------------------------------------------
+
+    async connect(): Promise<void> {
+        try {
+            // consola.info(`Connecting to ${this.destination}`.blue);
+            const cmd = `ssh ${this.identityArg} ${this.sshPortArg} -o StrictHostKeyChecking=accept-new -o ConnectTimeout=10 ${this.destination} echo connected`;
+            const output = await this.execWithPassword(cmd);
+
+            if (!output.includes("connected")) {
+                throw new Error("Connection verification failed");
+            }
+
+            this.connected = true;
+            consola.log(`✓ SFTP Connected to ${this.config.host}`.green);
+        } catch (error: any) {
+            // throw new Error(`Connexion échouée: ${error?.message}`);
+            consola.error(`Connexion échouée: ${error?.message}`);
+        }
+    }
+
+    async disconnect(): Promise<void> {
+        this.connected = false;
+        console.log(`✓ Déconnecté de ${this.config.host}`);
+    }
+
+    isConnected(): boolean {
+        return this.connected;
+    }
+
+    // --------------------------------------------------------------------------
+    // UPLOAD
+    // --------------------------------------------------------------------------
+
+    async syncCollectionMedia(col: Collection) {
+        if (!this.config?.remoteDir) this.config.remoteDir = "/home/" + col?.slug;
+
+        let visibility = col?.media?.visibility || "public";
+        let dirToWatch = path.join(process.cwd(), BASE_DIR, col?.slug, visibility);
+        dirToWatch = path.resolve(dirToWatch);
+        const watcher = chokidar.watch(dirToWatch, {
+            persistent: true,
+            ignoreInitial: true,
+            ignored: this.config.ignorePatterns || [],
+        });
+
+        watcher.on("all", (event, filePath) => {
+            // console.log(`SFTP: ${event} ${filePath}`);
+            if (event == "change" || event == "add") {
+                //consola.info(`SFTP: ${event} ${filePath}`);
+                let remotePath = path.join(
+                    this.config.remoteDir || '/home/' + col?.slug,
+                    path.basename(filePath)
+                );
+                this.upload(filePath, remotePath).catch(err => {
+                    consola.error(`${err?.message}`.red);
+                });
+            }
+        });
+    }
+    async upload(
+        localPath: string,
+        remotePath: string,
+        options?: UploadOptions
+    ): Promise<void> {
+        const file = Bun.file(localPath);
+
+        if (!(await file.exists())) {
+            throw new Error(`Fichier local introuvable: ${localPath}`);
+        }
+
+        const fileName = localPath.split("/").pop() || localPath;
+        if (this.shouldIgnore(fileName) || this.shouldIgnore(localPath)) {
+            console.log(`⊘ Ignoré: ${localPath}`);
+            return;
+        }
+
+        const resolvedPath = this.resolvePath(remotePath);
+
+        if (!options?.overwrite) {
+            const exists = await this.exists(resolvedPath);
+            if (exists) {
+                throw new Error(`Fichier distant existe déjà: ${resolvedPath}`);
+            }
+        }
+
+        const cmd = `scp ${this.identityArg} ${this.portArg} -o StrictHostKeyChecking=accept-new ${localPath} ${this.destination}:${resolvedPath}`;
+
+        await this.execWithPassword(cmd);
+        console.log(`✓ Upload: ${localPath} → ${resolvedPath}`);
+    }
+
+    async uploadMultiple(
+        files: { local: string; remote: string }[],
+        options?: UploadOptions
+    ): Promise<void> {
+        const filteredFiles = files.filter((file) => {
+            const fileName = file.local.split("/").pop() || file.local;
+            return !this.shouldIgnore(fileName) && !this.shouldIgnore(file.local);
+        });
+
+        const total = filteredFiles.length;
+        let uploaded = 0;
+
+        for (let i = 0; i < total; i++) {
+            const file = filteredFiles[i];
+            await this.upload(file.local, file.remote, { ...options, overwrite: options?.overwrite });
+            uploaded++;
+
+            if (options?.onProgress) {
+                options.onProgress(Math.round((uploaded / total) * 100));
+            }
+        }
+
+        console.log(`✓ ${uploaded} fichiers uploadés`);
+    }
+
+    async uploadDirectory(
+        localDir: string,
+        remoteDir?: string,
+        options?: UploadOptions
+    ): Promise<void> {
+        const targetDir = remoteDir ? this.resolvePath(remoteDir) : this.remoteDir;
+
+        // Get all files respecting ignorePatterns
+        const localFiles = await this.getLocalFiles(localDir);
+
+        // Create remote directory structure
+        const dirs = new Set<string>();
+        for (const file of localFiles) {
+            const dir = file.split("/").slice(0, -1).join("/");
+            if (dir) dirs.add(dir);
+        }
+
+        // Create directories
+        for (const dir of Array.from(dirs).sort()) {
+            const remoteDirPath = `${targetDir}/${dir}`;
+            try {
+                await this.mkdir(remoteDirPath, true);
+            } catch {
+                // Directory might already exist
+            }
+        }
+
+        // Upload files
+        const total = localFiles.length;
+        let uploaded = 0;
+
+        for (const file of localFiles) {
+            const localPath = join(localDir, file);
+            const remotePath = `${targetDir}/${file}`;
+
+            await this.upload(localPath, remotePath, { overwrite: true });
+            uploaded++;
+
+            if (options?.onProgress) {
+                options.onProgress(Math.round((uploaded / total) * 100));
+            }
+        }
+
+        console.log(`✓ Dossier uploadé: ${localDir} → ${targetDir} (${uploaded} fichiers)`);
+    }
+
+    // --------------------------------------------------------------------------
+    // DOWNLOAD
+    // --------------------------------------------------------------------------
+
+    async download(
+        remotePath: string,
+        localPath: string,
+        options?: DownloadOptions
+    ): Promise<void> {
+        const resolvedPath = this.resolvePath(remotePath);
+        const cmd = `scp ${this.identityArg} ${this.portArg} -o StrictHostKeyChecking=accept-new ${this.destination}:${resolvedPath} ${localPath}`;
+
+        await this.execWithPassword(cmd);
+        console.log(`✓ Download: ${resolvedPath} → ${localPath}`);
+    }
+
+    async downloadMultiple(
+        files: { remote: string; local: string }[],
+        options?: DownloadOptions
+    ): Promise<void> {
+        const total = files.length;
+
+        for (let i = 0; i < total; i++) {
+            const file = files[i];
+            await this.download(file.remote, file.local);
+
+            if (options?.onProgress) {
+                options.onProgress(Math.round(((i + 1) / total) * 100));
+            }
+        }
+
+        console.log(`✓ ${total} fichiers téléchargés`);
+    }
+
+    async downloadDirectory(
+        remoteDir: string,
+        localDir: string,
+        options?: DownloadOptions
+    ): Promise<void> {
+        const resolvedPath = this.resolvePath(remoteDir);
+        const cmd = `scp -r ${this.identityArg} ${this.portArg} -o StrictHostKeyChecking=accept-new ${this.destination}:${resolvedPath} ${localDir}`;
+
+        await this.execWithPassword(cmd);
+        console.log(`✓ Dossier téléchargé: ${resolvedPath} → ${localDir}`);
+    }
+
+    // --------------------------------------------------------------------------
+    // FILE OPERATIONS
+    // --------------------------------------------------------------------------
+
+    async list(remotePath?: string): Promise<string[]> {
+        const resolvedPath = remotePath ? this.resolvePath(remotePath) : this.remoteDir;
+        const output = await this.sshExec(`ls -1 "${resolvedPath}"`);
+        return this.cleanOutput(output);
+    }
+
+    async listDetailed(remotePath?: string): Promise<FileInfo[]> {
+        const resolvedPath = remotePath ? this.resolvePath(remotePath) : this.remoteDir;
+        const output = await this.sshExec(
+            `ls -la --time-style=+%s "${resolvedPath}" | tail -n +2`
+        );
+
+        const lines = this.cleanOutput(output);
+        const files: FileInfo[] = [];
+
+        for (const line of lines) {
+            const parts = line.split(/\s+/);
+            if (parts.length >= 7) {
+                const permissions = parts[0];
+                const size = parseInt(parts[4], 10);
+                const timestamp = parseInt(parts[5], 10);
+                const name = parts.slice(6).join(" ");
+
+                if (name && name !== "." && name !== "..") {
+                    files.push({
+                        name,
+                        size,
+                        isDirectory: permissions.startsWith("d"),
+                        modified: new Date(timestamp * 1000),
+                        permissions,
+                    });
+                }
+            }
+        }
+
+        return files;
+    }
+
+    async exists(remotePath: string): Promise<boolean> {
+        try {
+            const resolvedPath = this.resolvePath(remotePath);
+            const output = await this.sshExec(
+                `test -e "${resolvedPath}" && echo "EXISTS" || echo "NOT_EXISTS"`
+            );
+            return output.includes("EXISTS");
+        } catch {
+            return false;
+        }
+    }
+
+    async isDirectory(remotePath: string): Promise<boolean> {
+        try {
+            const resolvedPath = this.resolvePath(remotePath);
+            const output = await this.sshExec(
+                `test -d "${resolvedPath}" && echo "YES" || echo "NO"`
+            );
+            return output.includes("YES");
+        } catch {
+            return false;
+        }
+    }
+
+    async isFile(remotePath: string): Promise<boolean> {
+        try {
+            const resolvedPath = this.resolvePath(remotePath);
+            const output = await this.sshExec(
+                `test -f "${resolvedPath}" && echo "YES" || echo "NO"`
+            );
+            return output.includes("YES");
+        } catch {
+            return false;
+        }
+    }
+
+    async stat(remotePath: string): Promise<FileInfo> {
+        const resolvedPath = this.resolvePath(remotePath);
+        const output = await this.sshExec(
+            `stat -c '%n %s %F %Y %A' "${resolvedPath}"`
+        );
+
+        const line = this.cleanOutput(output)[0];
+        const parts = line.split(" ");
+
+        return {
+            name: parts[0],
+            size: parseInt(parts[1], 10),
+            isDirectory: parts[2] === "directory",
+            modified: new Date(parseInt(parts[3], 10) * 1000),
+            permissions: parts[4],
+        };
+    }
+
+    async size(remotePath: string): Promise<number> {
+        const resolvedPath = this.resolvePath(remotePath);
+        const output = await this.sshExec(`stat -c '%s' "${resolvedPath}"`);
+        return parseInt(this.cleanOutput(output)[0], 10);
+    }
+
+    // --------------------------------------------------------------------------
+    // DIRECTORY OPERATIONS
+    // --------------------------------------------------------------------------
+
+    async mkdir(remotePath: string, recursive = false): Promise<void> {
+        const resolvedPath = this.resolvePath(remotePath);
+        const flag = recursive ? "-p" : "";
+        await this.sshExec(`mkdir ${flag} "${resolvedPath}"`);
+        console.log(`✓ Dossier créé: ${resolvedPath}`);
+    }
+
+    async rmdir(remotePath: string, recursive = false): Promise<void> {
+        const resolvedPath = this.resolvePath(remotePath);
+        const flag = recursive ? "-rf" : "-d";
+        await this.sshExec(`rm ${flag} "${resolvedPath}"`);
+        console.log(`✓ Dossier supprimé: ${resolvedPath}`);
+    }
+
+    // --------------------------------------------------------------------------
+    // FILE MANIPULATION
+    // --------------------------------------------------------------------------
+
+    async delete(remotePath: string): Promise<void> {
+        const resolvedPath = this.resolvePath(remotePath);
+        await this.sshExec(`rm -f "${resolvedPath}"`);
+        console.log(`✓ Fichier supprimé: ${resolvedPath}`);
+    }
+
+    async rename(oldPath: string, newPath: string): Promise<void> {
+        const resolvedOld = this.resolvePath(oldPath);
+        const resolvedNew = this.resolvePath(newPath);
+        await this.sshExec(`mv "${resolvedOld}" "${resolvedNew}"`);
+        console.log(`✓ Renommé: ${resolvedOld} → ${resolvedNew}`);
+    }
+
+    async copy(srcPath: string, destPath: string): Promise<void> {
+        const resolvedSrc = this.resolvePath(srcPath);
+        const resolvedDest = this.resolvePath(destPath);
+        await this.sshExec(`cp "${resolvedSrc}" "${resolvedDest}"`);
+        console.log(`✓ Copié: ${resolvedSrc} → ${resolvedDest}`);
+    }
+
+    async chmod(remotePath: string, mode: string | number): Promise<void> {
+        const resolvedPath = this.resolvePath(remotePath);
+        await this.sshExec(`chmod ${mode} "${resolvedPath}"`);
+        console.log(`✓ Permissions: ${resolvedPath} → ${mode}`);
+    }
+
+    async chown(remotePath: string, owner: string, group?: string): Promise<void> {
+        const resolvedPath = this.resolvePath(remotePath);
+        const ownerGroup = group ? `${owner}:${group}` : owner;
+        await this.sshExec(`chown ${ownerGroup} "${resolvedPath}"`);
+        console.log(`✓ Propriétaire: ${resolvedPath} → ${ownerGroup}`);
+    }
+
+    // --------------------------------------------------------------------------
+    // CONTENT OPERATIONS
+    // --------------------------------------------------------------------------
+
+    async readFile(remotePath: string): Promise<string> {
+        const resolvedPath = this.resolvePath(remotePath);
+        return await this.sshExec(`cat "${resolvedPath}"`);
+    }
+
+    async writeFile(remotePath: string, content: string): Promise<void> {
+        const resolvedPath = this.resolvePath(remotePath);
+        const tempFile = join(tmpdir(), `write-${Date.now()}`);
+        await Bun.write(tempFile, content);
+
+        try {
+            const cmd = `scp ${this.identityArg} ${this.portArg} -o StrictHostKeyChecking=accept-new ${tempFile} ${this.destination}:${resolvedPath}`;
+            await this.execWithPassword(cmd);
+            console.log(`✓ Fichier écrit: ${resolvedPath}`);
+        } finally {
+            await $`rm -f ${tempFile}`.quiet().nothrow();
+        }
+    }
+
+    async appendFile(remotePath: string, content: string): Promise<void> {
+        const resolvedPath = this.resolvePath(remotePath);
+        const escaped = content.replace(/'/g, "'\\''");
+        await this.sshExec(`echo '${escaped}' >> "${resolvedPath}"`);
+    }
+
+    // --------------------------------------------------------------------------
+    // UTILITY
+    // --------------------------------------------------------------------------
+
+    async exec(command: string): Promise<string> {
+        return await this.sshExec(command);
+    }
+
+    async df(remotePath?: string): Promise<{ total: number; used: number; available: number }> {
+        const resolvedPath = remotePath ? this.resolvePath(remotePath) : this.remoteDir;
+        const output = await this.sshExec(`df -B1 "${resolvedPath}" | tail -1`);
+        const parts = this.cleanOutput(output)[0].split(/\s+/);
+
+        return {
+            total: parseInt(parts[1], 10),
+            used: parseInt(parts[2], 10),
+            available: parseInt(parts[3], 10),
+        };
+    }
+
+    async whoami(): Promise<string> {
+        const output = await this.sshExec("whoami");
+        return this.cleanOutput(output)[0];
+    }
+
+    async pwd(): Promise<string> {
+        const output = await this.sshExec("pwd");
+        return this.cleanOutput(output)[0];
+    }
+
+    // --------------------------------------------------------------------------
+    // GETTERS & SETTERS
+    // --------------------------------------------------------------------------
+
+    getRemoteDir(): string {
+        return this.remoteDir;
+    }
+
+    setRemoteDir(dir: string): void {
+        this.remoteDir = dir;
+    }
+
+    getIgnorePatterns(): string[] {
+        return [...this.ignorePatterns];
+    }
+
+    setIgnorePatterns(patterns: string[]): void {
+        this.ignorePatterns = patterns;
+    }
+
+    addIgnorePattern(pattern: string): void {
+        if (!this.ignorePatterns.includes(pattern)) {
+            this.ignorePatterns.push(pattern);
+        }
+    }
+
+    removeIgnorePattern(pattern: string): void {
+        this.ignorePatterns = this.ignorePatterns.filter((p) => p !== pattern);
+    }
 }
 
-export { FilesystemSftpAdapter };
+// ============================================================================
+// EXPORTS
+// ============================================================================
+
+export {
+    FilesystemSftpAdapter,
+    type SftpConfig,
+    type FileInfo,
+    type UploadOptions,
+    type DownloadOptions,
+};