@dnax/core 0.77.9-alpha-1 → 0.78.0

package/app/hono.ts

@@ -14,7 +14,7 @@ import { serveStatic, getConnInfo } from "hono/bun";
 import { consola } from "consola";
 
 import { cors } from "hono/cors";
-import { asyncLocalStorage, sessionStorage,requestStorage } from "../lib/asyncLocalStorage";
+import { asyncLocalStorage, sessionStorage, requestStorage } from "../lib/asyncLocalStorage";
 import { crypt } from "../lib/crypto";
 import { plugins } from "../lib/plugins";
 import {
@@ -305,7 +305,7 @@ function HonoInstance(): typeof app {
           ?.get("content-type")
           ?.match(/(multipart\/form-data)/) ||
         c.req?.raw?.headers.get("content-type") ==
-          "application/x-www-form-urlencoded"
+        "application/x-www-form-urlencoded"
       ) {
         parseBody =
           (await c?.req.parseBody({
@@ -818,7 +818,7 @@ function HonoInstance(): typeof app {
       if (Cfg?.api?.onError && typeof Cfg?.api?.onError == "function") {
         try {
           await Cfg?.api?.onError(errorFormated, err);
-        } catch (e) {}
+        } catch (e) { }
       }
       return c.json(errorFormated);
     }

package/app/index.ts

@@ -92,7 +92,7 @@ async function runApp(config?: configRunApp, clb?: Function): Promise<Server> {
           });
           info += `\n\n`;
           info += `🔄 ${new Date().toLocaleString()}`.gray;
-        
+
           if (clb) clb();
 
           console.log();

package/index.ts

@@ -6,13 +6,12 @@ import * as v from "joi";
 import { $ } from "bun";
 import define from "./define";
 import * as utils from "./utils";
-import { app } from "./app/hono";
 import { FilesystemSftpAdapter, MinioAdapter } from "./lib/media";
 import { crypt } from "./lib/crypto";
 import { plugins } from "./lib/plugins";
 import { contextStorage } from "./lib/asyncLocalStorage";
 import { Cron as Task } from "croner";
-import { serveStatic } from "hono/bun";
+//import { serveStatic } from "hono/bun";
 import { useDatabaseTools } from "./driver/mongo/database";
 import { useCache } from "./lib/bento";
 // Adapter

package/lib/media/sftp.ts

@@ -1,116 +1,670 @@
-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;
-};
+
+// ============================================================================
+// 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 {
-  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;
-  }
+    private config: SftpConfig;
+    private connected: boolean = false;
+    private remoteDir: string;
+    private ignorePatterns: string[];
+    type: "sftp";
 
-  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)
-        );
-        this.put(filePath, remotePath);
-      }
-    });
-  }
+    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()
+    }
+
+    // --------------------------------------------------------------------------
+    // 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;
 
-  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);
+        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;
             }
-            resolve({
-              sftp: sftp,
-              conn: this.conn,
-            });
-          });
-        })
-        .on("error", (err) => reject(err?.message))
-        .connect(this.config);
-    });
+
+            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);
+            }
+        }
+
+        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();
+        }
+
+        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);
+    }
+}
+
+// ============================================================================
+// EXPORTS
+// ============================================================================
 
-export { FilesystemSftpAdapter };
+export {
+    FilesystemSftpAdapter,
+    type SftpConfig,
+    type FileInfo,
+    type UploadOptions,
+    type DownloadOptions,
+};

package/lib/media/sftp_.txt

@@ -0,0 +1,120 @@
+import { Client } from "ssh2";
+import type { SFTPWrapper } from "ssh2";
+import { consola } from "consola";
+import path from "path";
+import chokidar from "chokidar";
+import fs from "fs-extra";
+import type { Collection } from "../../types";
+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();
+
+    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)
+        );
+        this.put(filePath, remotePath);
+      }
+    });
+  }
+
+  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);
+            }
+            resolve({
+              sftp: sftp,
+              conn: this.conn,
+            });
+          });
+        })
+        .on("error", (err) => {
+          this.conn.end();
+          reject(err?.message)
+        })
+        .connect(this.config);
+    });
+  }
+  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);
+        }
+      );
+    });
+  }
+}
+
+export { FilesystemSftpAdapter };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dnax/core",
-  "version": "0.77.9-alpha-1",
+  "version": "0.78.0",
   "module": "index.ts",
   "type": "module",
   "bin": {},
@@ -15,7 +15,7 @@
     "@types/uuid": "^11.0.0"
   },
   "peerDependencies": {
-    "typescript": "^5.9.2"
+    "typescript": "^5.9.3"
   },
   "dependencies": {
     "@colors/colors": "^1.6.0",
@@ -33,7 +33,7 @@
     "dot-object": "2.1.5",
     "fs-extra": "^11.2.0",
     "generate-unique-id": "^2.0.3",
-    "hono": "4.10.7",
+    "hono": "4.11.7",
     "joi": "18.0.2",
     "json-joy": "16.8.0",
     "jsonwebtoken": "^9.0.3",
@@ -48,7 +48,6 @@
     "radash": "^12.1.0",
     "rfc6902": "^5.1.2",
     "sharp": "^0.34.5",
-    "ssh2": "^1.17.0",
     "ufo": "^1.5.4",
     "urlencode": "^2.0.0",
     "uuid": "^13.0.0"