@cadriciel/module-sftp 0.1.4

package/.turbo/turbo-build.log

@@ -0,0 +1,2 @@
+
+$ tsc

package/README.md

@@ -0,0 +1,25 @@
+# 📦 @cadriciel/module-sftp
+
+Unified file management and SFTP integration for the Cadriciel framework.
+
+## Features
+
+- **SFTPGo Integration**: Manage users and folders via SFTPGo.
+- **Minio Integration**: S3-compatible object storage support.
+- **Automated Provisioning**: Programmatically create SFTP users and manage access.
+- **Unified API**: Abstract file operations across different storage backends.
+
+## Usage
+
+```typescript
+import SftpModule from "@cadriciel/module-sftp";
+
+kernel.load(SftpModule);
+```
+
+## Configuration
+
+Requires environment variables for SFTPGo connection:
+- `SFTPGO_URL`
+- `SFTPGO_ADMIN_USER`
+- `SFTPGO_ADMIN_PASSWORD`

package/dist/index.js

@@ -0,0 +1,40 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./service"), exports);
+const service_1 = require("./service");
+exports.default = {
+    name: 'sftp',
+    setup(ctx) {
+        if (ctx.logger) {
+            ctx.logger.log('📦 SFTP module loaded');
+        }
+        // Initialize service with config
+        const service = new service_1.SftpService(ctx.env || process.env);
+        if (ctx.services) {
+            ctx.services.set('sftp', service);
+        }
+    },
+    routes(ctx) {
+        const sftpService = ctx.services.get('sftp');
+        if (!sftpService)
+            return;
+        ctx.app.use('*', async (c, next) => {
+            c.set('sftp', sftpService);
+            await next();
+        });
+    }
+};

package/dist/service.js

@@ -0,0 +1,225 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SftpService = void 0;
+const axios_1 = __importDefault(require("axios"));
+const Minio = __importStar(require("minio"));
+class SftpService {
+    client;
+    baseURL;
+    adminUser;
+    adminPassword;
+    s3Config;
+    token;
+    tokenExpiresAt;
+    minioClient;
+    constructor(env) {
+        this.baseURL = env.SFTPGO_URL || '';
+        this.adminUser = env.SFTPGO_ADMIN_USER || '';
+        this.adminPassword = env.SFTPGO_ADMIN_PASSWORD;
+        this.s3Config = {
+            url: env.SFTPGO_S3_URL,
+            region: env.SFTPGO_S3_REGION || "us-east-1",
+            accessKey: env.SFTPGO_S3_ACCESS_KEY,
+            secretKey: env.SFTPGO_S3_SECRET_KEY,
+            bucket: env.SFTPGO_S3_BUCKET,
+        };
+        if (this.baseURL && this.adminUser && this.adminPassword) {
+            console.log(`✅ SftpGoService initialized with URL: ${this.baseURL}`);
+        }
+        else {
+            console.warn("⚠️ SftpGo configuration missing (SFTPGO_URL, SFTPGO_ADMIN_USER, SFTPGO_ADMIN_PASSWORD)");
+        }
+        this.client = axios_1.default.create({
+            baseURL: this.baseURL,
+            timeout: 10000,
+        });
+        if (this.s3Config.url && this.s3Config.accessKey && this.s3Config.secretKey) {
+            try {
+                const parsedUrl = new URL(this.s3Config.url);
+                this.minioClient = new Minio.Client({
+                    endPoint: parsedUrl.hostname,
+                    port: parseInt(parsedUrl.port) || (parsedUrl.protocol === "https:" ? 443 : 80),
+                    useSSL: parsedUrl.protocol === "https:",
+                    accessKey: this.s3Config.accessKey,
+                    secretKey: this.s3Config.secretKey,
+                    region: this.s3Config.region,
+                });
+                console.log(`✅ Minio client initialized for bucket: ${this.s3Config.bucket}`);
+            }
+            catch (error) {
+                console.error("❌ Error initializing Minio client:", error.message);
+            }
+        }
+    }
+    async ensureBucketExists() {
+        if (!this.minioClient || !this.s3Config.bucket)
+            return;
+        try {
+            const exists = await this.minioClient.bucketExists(this.s3Config.bucket);
+            if (!exists) {
+                console.log(`🪣 Creating S3 bucket: ${this.s3Config.bucket}...`);
+                await this.minioClient.makeBucket(this.s3Config.bucket, this.s3Config.region);
+                console.log(`✅ Bucket ${this.s3Config.bucket} created successfully.`);
+            }
+        }
+        catch (error) {
+            console.error(`❌ Error checking/creating bucket ${this.s3Config.bucket}:`, error.message);
+        }
+    }
+    async ensureAuth() {
+        const now = Date.now();
+        const safetyMargin = 60 * 1000;
+        if (this.token && this.tokenExpiresAt && (this.tokenExpiresAt - now > safetyMargin)) {
+            return;
+        }
+        try {
+            const auth = Buffer.from(`${this.adminUser}:${this.adminPassword}`).toString('base64');
+            const response = await this.client.get("/api/v2/token", {
+                headers: {
+                    Authorization: `Basic ${auth}`
+                }
+            });
+            this.token = response.data.access_token;
+            // SFTPGo returns expires_at as ISO string date
+            this.tokenExpiresAt = new Date(response.data.expires_at).getTime();
+            // console.log(`✅ New SFTPGo token obtained`);
+        }
+        catch (error) {
+            console.error("❌ SFTPGo Authentication Error:", error.message);
+            throw new Error(`Cannot authenticate with SFTPGo: ${error.message}`);
+        }
+    }
+    async createUser(username, password) {
+        await this.ensureAuth();
+        let userPayload = {
+            username: username,
+            password: password,
+            status: 1, // active
+            permissions: {
+                "/": ["*"]
+            }
+        };
+        if (this.s3Config.bucket && this.minioClient) {
+            await this.ensureBucketExists();
+            let sftpGoEndpoint = this.s3Config.url;
+            if (sftpGoEndpoint.includes("localhost")) {
+                sftpGoEndpoint = sftpGoEndpoint.replace("localhost", "minio");
+            }
+            userPayload.filesystem = {
+                provider: 1, // S3
+                s3config: {
+                    bucket: this.s3Config.bucket,
+                    region: this.s3Config.region,
+                    access_key: this.s3Config.accessKey,
+                    access_secret: {
+                        status: "Plain",
+                        payload: this.s3Config.secretKey
+                    },
+                    endpoint: sftpGoEndpoint,
+                    key_prefix: `${username}/`,
+                    force_path_style: true
+                }
+            };
+            userPayload.home_dir = `/srv/sftpgo/data/${username}`;
+        }
+        else {
+            userPayload.home_dir = `/srv/sftpgo/data/${username}`;
+            userPayload.uid = 0;
+            userPayload.gid = 0;
+        }
+        try {
+            const response = await this.client.post("/api/v2/users", userPayload, {
+                headers: { Authorization: `Bearer ${this.token}` }
+            });
+            console.log(`✅ SFTPGo user created: ${username}`);
+            return response.data;
+        }
+        catch (error) {
+            if (error.response?.status === 409) {
+                console.log(`⚠️ User ${username} already exists, updating...`);
+                return this.updateUser(username, userPayload);
+            }
+            throw error;
+        }
+    }
+    async updateUser(username, userPayload) {
+        await this.ensureAuth();
+        const id = await this.getUserId(username);
+        if (id)
+            userPayload.id = id;
+        try {
+            const response = await this.client.put(`/api/v2/users/${id || username}`, userPayload, {
+                headers: { Authorization: `Bearer ${this.token}` }
+            });
+            console.log(`✅ SFTPGo user updated: ${username}`);
+            return response.data;
+        }
+        catch (error) {
+            console.error(`❌ Error updating SFTPGo user ${username}:`, error.message);
+            throw error;
+        }
+    }
+    async getUserId(username) {
+        try {
+            const response = await this.client.get(`/api/v2/users/${username}`, {
+                headers: { Authorization: `Bearer ${this.token}` }
+            });
+            return response.data.id;
+        }
+        catch (e) {
+            return null;
+        }
+    }
+    async deleteUser(username) {
+        await this.ensureAuth();
+        try {
+            await this.client.delete(`/api/v2/users/${username}`, {
+                headers: { Authorization: `Bearer ${this.token}` }
+            });
+            console.log(`✅ SFTPGo user deleted: ${username}`);
+        }
+        catch (error) {
+            if (error.response?.status === 404)
+                return;
+            console.error(`❌ Error deleting SFTPGo user ${username}:`, error.message);
+            throw error;
+        }
+    }
+}
+exports.SftpService = SftpService;

package/package.json

@@ -0,0 +1,17 @@
+{
+    "name": "@cadriciel/module-sftp",
+    "version": "0.1.4",
+    "description": "SFTPGo integration module",
+    "main": "src/index.ts",
+    "scripts": {
+        "build": "tsc"
+    },
+    "dependencies": {
+        "@cadriciel/kernel": "workspace:*",
+        "axios": "^1.13.2",
+        "minio": "^8.0.6"
+    },
+    "peerDependencies": {
+        "typescript": "^5.0.0"
+    }
+}

package/src/index.ts

@@ -0,0 +1,27 @@
+export * from './service';
+import { SftpService } from './service';
+
+export default {
+    name: 'sftp',
+    setup(ctx: any) {
+        if (ctx.logger) {
+            ctx.logger.log('📦 SFTP module loaded');
+        }
+
+        // Initialize service with config
+        const service = new SftpService(ctx.env || process.env);
+
+        if (ctx.services) {
+            ctx.services.set('sftp', service);
+        }
+    },
+    routes(ctx: any) {
+        const sftpService = ctx.services.get('sftp');
+        if (!sftpService) return;
+
+        ctx.app.use('*', async (c: any, next: any) => {
+            c.set('sftp', sftpService);
+            await next();
+        });
+    }
+};

package/src/service.ts

@@ -0,0 +1,209 @@
+import axios, { AxiosInstance } from 'axios';
+import * as Minio from 'minio';
+
+export interface SftpUserPayload {
+    username: string;
+    password?: string;
+    status?: number;
+    permissions?: any;
+    home_dir?: string;
+    uid?: number;
+    gid?: number;
+    filesystem?: {
+        provider: number;
+        s3config?: any;
+    };
+    id?: number;
+}
+
+export class SftpService {
+    private client: AxiosInstance;
+    private baseURL: string;
+    private adminUser: string;
+    private adminPassword?: string;
+    private s3Config: any;
+    private token?: string;
+    private tokenExpiresAt?: number;
+    private minioClient?: Minio.Client;
+
+    constructor(env: any) {
+        this.baseURL = env.SFTPGO_URL || '';
+        this.adminUser = env.SFTPGO_ADMIN_USER || '';
+        this.adminPassword = env.SFTPGO_ADMIN_PASSWORD;
+
+        this.s3Config = {
+            url: env.SFTPGO_S3_URL,
+            region: env.SFTPGO_S3_REGION || "us-east-1",
+            accessKey: env.SFTPGO_S3_ACCESS_KEY,
+            secretKey: env.SFTPGO_S3_SECRET_KEY,
+            bucket: env.SFTPGO_S3_BUCKET,
+        };
+
+        if (this.baseURL && this.adminUser && this.adminPassword) {
+            console.log(`✅ SftpGoService initialized with URL: ${this.baseURL}`);
+        } else {
+            console.warn("⚠️ SftpGo configuration missing (SFTPGO_URL, SFTPGO_ADMIN_USER, SFTPGO_ADMIN_PASSWORD)");
+        }
+
+        this.client = axios.create({
+            baseURL: this.baseURL,
+            timeout: 10000,
+        });
+
+        if (this.s3Config.url && this.s3Config.accessKey && this.s3Config.secretKey) {
+            try {
+                const parsedUrl = new URL(this.s3Config.url);
+                this.minioClient = new Minio.Client({
+                    endPoint: parsedUrl.hostname,
+                    port: parseInt(parsedUrl.port) || (parsedUrl.protocol === "https:" ? 443 : 80),
+                    useSSL: parsedUrl.protocol === "https:",
+                    accessKey: this.s3Config.accessKey,
+                    secretKey: this.s3Config.secretKey,
+                    region: this.s3Config.region,
+                });
+                console.log(`✅ Minio client initialized for bucket: ${this.s3Config.bucket}`);
+            } catch (error: any) {
+                console.error("❌ Error initializing Minio client:", error.message);
+            }
+        }
+    }
+
+    private async ensureBucketExists() {
+        if (!this.minioClient || !this.s3Config.bucket) return;
+
+        try {
+            const exists = await this.minioClient.bucketExists(this.s3Config.bucket);
+            if (!exists) {
+                console.log(`🪣 Creating S3 bucket: ${this.s3Config.bucket}...`);
+                await this.minioClient.makeBucket(this.s3Config.bucket, this.s3Config.region);
+                console.log(`✅ Bucket ${this.s3Config.bucket} created successfully.`);
+            }
+        } catch (error: any) {
+            console.error(`❌ Error checking/creating bucket ${this.s3Config.bucket}:`, error.message);
+        }
+    }
+
+    private async ensureAuth() {
+        const now = Date.now();
+        const safetyMargin = 60 * 1000;
+
+        if (this.token && this.tokenExpiresAt && (this.tokenExpiresAt - now > safetyMargin)) {
+            return;
+        }
+
+        try {
+            const auth = Buffer.from(`${this.adminUser}:${this.adminPassword}`).toString('base64');
+            const response = await this.client.get("/api/v2/token", {
+                headers: {
+                    Authorization: `Basic ${auth}`
+                }
+            });
+
+            this.token = response.data.access_token;
+            // SFTPGo returns expires_at as ISO string date
+            this.tokenExpiresAt = new Date(response.data.expires_at).getTime();
+            // console.log(`✅ New SFTPGo token obtained`);
+        } catch (error: any) {
+            console.error("❌ SFTPGo Authentication Error:", error.message);
+            throw new Error(`Cannot authenticate with SFTPGo: ${error.message}`);
+        }
+    }
+
+    async createUser(username: string, password?: string) {
+        await this.ensureAuth();
+
+        let userPayload: SftpUserPayload = {
+            username: username,
+            password: password,
+            status: 1, // active
+            permissions: {
+                "/": ["*"]
+            }
+        };
+
+        if (this.s3Config.bucket && this.minioClient) {
+            await this.ensureBucketExists();
+            let sftpGoEndpoint = this.s3Config.url;
+            if (sftpGoEndpoint.includes("localhost")) {
+                sftpGoEndpoint = sftpGoEndpoint.replace("localhost", "minio");
+            }
+
+            userPayload.filesystem = {
+                provider: 1, // S3
+                s3config: {
+                    bucket: this.s3Config.bucket,
+                    region: this.s3Config.region,
+                    access_key: this.s3Config.accessKey,
+                    access_secret: {
+                        status: "Plain",
+                        payload: this.s3Config.secretKey
+                    },
+                    endpoint: sftpGoEndpoint,
+                    key_prefix: `${username}/`,
+                    force_path_style: true
+                }
+            };
+            userPayload.home_dir = `/srv/sftpgo/data/${username}`;
+        } else {
+            userPayload.home_dir = `/srv/sftpgo/data/${username}`;
+            userPayload.uid = 0;
+            userPayload.gid = 0;
+        }
+
+        try {
+            const response = await this.client.post("/api/v2/users", userPayload, {
+                headers: { Authorization: `Bearer ${this.token}` }
+            });
+            console.log(`✅ SFTPGo user created: ${username}`);
+            return response.data;
+        } catch (error: any) {
+            if (error.response?.status === 409) {
+                console.log(`⚠️ User ${username} already exists, updating...`);
+                return this.updateUser(username, userPayload);
+            }
+            throw error;
+        }
+    }
+
+    async updateUser(username: string, userPayload: SftpUserPayload) {
+        await this.ensureAuth();
+        const id = await this.getUserId(username);
+        if (id) userPayload.id = id;
+
+        try {
+            const response = await this.client.put(`/api/v2/users/${id || username}`, userPayload, {
+                headers: { Authorization: `Bearer ${this.token}` }
+            });
+            console.log(`✅ SFTPGo user updated: ${username}`);
+            return response.data;
+        } catch (error: any) {
+            console.error(`❌ Error updating SFTPGo user ${username}:`, error.message);
+            throw error;
+        }
+    }
+
+    async getUserId(username: string): Promise<number | null> {
+        try {
+            const response = await this.client.get(`/api/v2/users/${username}`, {
+                headers: { Authorization: `Bearer ${this.token}` }
+            });
+            return response.data.id;
+        } catch (e) {
+            return null;
+        }
+    }
+
+    async deleteUser(username: string) {
+        await this.ensureAuth();
+        try {
+            await this.client.delete(`/api/v2/users/${username}`, {
+                headers: { Authorization: `Bearer ${this.token}` }
+            });
+            console.log(`✅ SFTPGo user deleted: ${username}`);
+        } catch (error: any) {
+            if (error.response?.status === 404) return;
+            console.error(`❌ Error deleting SFTPGo user ${username}:`, error.message);
+            throw error;
+        }
+    }
+}

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+    "compilerOptions": {
+        "target": "ESNext",
+        "module": "CommonJS",
+        "outDir": "./dist",
+        "rootDir": "./src",
+        "strict": true,
+        "esModuleInterop": true,
+        "skipLibCheck": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "include": [
+        "src/**/*"
+    ]
+}