@kadi.build/file-manager 1.0.0

package/src/providers/RemoteProvider.js

@@ -0,0 +1,514 @@
+/**
+ * RemoteProvider - SSH/SFTP-based remote file operations
+ *
+ * Mirrors LocalProvider API for seamless local/remote operations
+ */
+
+import { EventEmitter } from 'events';
+import { Client } from 'ssh2';
+import SftpClient from 'ssh2-sftp-client';
+import path from 'path';
+import { promises as fs } from 'fs';
+
+class RemoteProvider extends EventEmitter {
+  constructor(config) {
+    super();
+    this.config = config || {};
+
+    // Connection settings
+    this.host = this.config.host;
+    this.port = this.config.port || 22;
+    // Backfill config.port so external access sees the default
+    this.config.port = this.port;
+    this.username = this.config.username;
+    this.password = this.config.password;
+    this.privateKey = this.config.privateKey;
+    this.privateKeyPath = this.config.privateKeyPath;
+    this.passphrase = this.config.passphrase;
+    this.remoteRoot = this.config.remoteRoot || '/home';
+
+    // Jump host / bastion support
+    this.bastionHost = this.config.bastionHost;
+    this.bastionPort = this.config.bastionPort || 22;
+    this.bastionUsername = this.config.bastionUsername;
+    this.bastionPrivateKey = this.config.bastionPrivateKey;
+
+    // State
+    this.sftp = null;
+    this.sshClient = null;
+    this.isConnected = false;
+
+    // Settings
+    this.maxFileSize = this.config.maxFileSize || 1073741824; // 1GB
+    this.timeout = this.config.timeout || 30000;
+  }
+
+  // ============================================================================
+  // CONNECTION MANAGEMENT
+  // ============================================================================
+
+  async connect() {
+    if (this.isConnected) {
+      return { status: 'already_connected' };
+    }
+
+    try {
+      // Load private key if path provided
+      let privateKey = this.privateKey;
+      if (!privateKey && this.privateKeyPath) {
+        const keyPath = this.privateKeyPath.replace('~', process.env.HOME);
+        privateKey = await fs.readFile(keyPath, 'utf8');
+      }
+
+      // Build connection config
+      const connectionConfig = {
+        host: this.host,
+        port: this.port,
+        username: this.username,
+        readyTimeout: this.timeout,
+        ...(privateKey && { privateKey }),
+        ...(this.password && { password: this.password }),
+        ...(this.passphrase && { passphrase: this.passphrase })
+      };
+
+      // Connect via SFTP client
+      this.sftp = new SftpClient();
+
+      if (this.bastionHost) {
+        await this._connectViaBastionHost(connectionConfig, privateKey);
+      } else {
+        await this.sftp.connect(connectionConfig);
+      }
+
+      this.isConnected = true;
+      this.emit('connected', { host: this.host });
+
+      return {
+        status: 'connected',
+        host: this.host,
+        username: this.username
+      };
+    } catch (error) {
+      this.emit('error', { type: 'connection', error: error.message });
+      throw new Error(`Failed to connect to ${this.host}: ${error.message}`);
+    }
+  }
+
+  async _connectViaBastionHost(targetConfig, privateKey) {
+    const bastionClient = new Client();
+
+    return new Promise((resolve, reject) => {
+      bastionClient.on('ready', () => {
+        bastionClient.forwardOut(
+          '127.0.0.1', 0,
+          this.host, this.port,
+          async (err, stream) => {
+            if (err) return reject(err);
+
+            try {
+              await this.sftp.connect({
+                ...targetConfig,
+                sock: stream
+              });
+              resolve();
+            } catch (e) {
+              reject(e);
+            }
+          }
+        );
+      });
+
+      bastionClient.on('error', reject);
+
+      bastionClient.connect({
+        host: this.bastionHost,
+        port: this.bastionPort,
+        username: this.bastionUsername,
+        privateKey: this.bastionPrivateKey || privateKey
+      });
+    });
+  }
+
+  async disconnect() {
+    if (this.sftp) {
+      await this.sftp.end();
+      this.sftp = null;
+    }
+    this.isConnected = false;
+    this.emit('disconnected');
+    return { status: 'disconnected' };
+  }
+
+  async testConnection() {
+    try {
+      await this.connect();
+      const cwd = await this.sftp.cwd();
+      await this.disconnect();
+
+      return {
+        provider: 'remote',
+        host: this.host,
+        username: this.username,
+        accessible: true,
+        currentDirectory: cwd
+      };
+    } catch (error) {
+      return {
+        provider: 'remote',
+        host: this.host,
+        accessible: false,
+        error: error.message
+      };
+    }
+  }
+
+  // ============================================================================
+  // FILE OPERATIONS (mirrors LocalProvider)
+  // ============================================================================
+
+  async uploadFile(localPath, remotePath) {
+    await this._ensureConnected();
+
+    const resolvedRemotePath = this._normalizePath(remotePath);
+
+    // Ensure remote directory exists
+    const remoteDir = path.dirname(resolvedRemotePath);
+    await this._ensureRemoteDirectory(remoteDir);
+
+    // Upload file
+    await this.sftp.put(localPath, resolvedRemotePath);
+
+    // Get uploaded file info
+    const stat = await this.sftp.stat(resolvedRemotePath);
+
+    return {
+      name: path.basename(remotePath),
+      path: resolvedRemotePath,
+      size: stat.size,
+      modifiedTime: new Date(stat.modifyTime * 1000).toISOString()
+    };
+  }
+
+  async downloadFile(remotePath, localPath) {
+    await this._ensureConnected();
+
+    const resolvedRemotePath = this._normalizePath(remotePath);
+
+    // Ensure local directory exists
+    const localDir = path.dirname(localPath);
+    await fs.mkdir(localDir, { recursive: true });
+
+    // Download file
+    await this.sftp.get(resolvedRemotePath, localPath);
+
+    // Get local file info
+    const stat = await fs.stat(localPath);
+
+    return {
+      name: path.basename(localPath),
+      path: localPath,
+      size: stat.size,
+      modifiedTime: stat.mtime.toISOString()
+    };
+  }
+
+  async getFile(remotePath) {
+    await this._ensureConnected();
+
+    const resolvedPath = this._normalizePath(remotePath);
+    const stat = await this.sftp.stat(resolvedPath);
+
+    return {
+      name: path.basename(remotePath),
+      path: resolvedPath,
+      size: stat.size,
+      isFile: stat.isFile,
+      isDirectory: stat.isDirectory,
+      modifiedTime: new Date(stat.modifyTime * 1000).toISOString(),
+      accessTime: new Date(stat.accessTime * 1000).toISOString(),
+      permissions: stat.mode
+    };
+  }
+
+  async listFiles(directoryPath, options = {}) {
+    await this._ensureConnected();
+
+    const resolvedPath = this._normalizePath(directoryPath);
+    const listing = await this.sftp.list(resolvedPath);
+
+    const files = listing
+      .filter(item => item.type === '-')
+      .map(item => ({
+        name: item.name,
+        path: path.join(resolvedPath, item.name),
+        relativePath: item.name,
+        size: item.size,
+        modifiedTime: new Date(item.modifyTime).toISOString(),
+        permissions: item.rights
+      }));
+
+    if (options.recursive) {
+      const dirs = listing.filter(item => item.type === 'd' && item.name !== '.' && item.name !== '..');
+      for (const dir of dirs) {
+        const subPath = path.join(directoryPath, dir.name);
+        const subFiles = await this.listFiles(subPath, options);
+        files.push(...subFiles.map(f => ({
+          ...f,
+          relativePath: path.join(dir.name, f.relativePath)
+        })));
+      }
+    }
+
+    return files;
+  }
+
+  async deleteFile(remotePath) {
+    await this._ensureConnected();
+
+    const resolvedPath = this._normalizePath(remotePath);
+    await this.sftp.delete(resolvedPath);
+
+    return {
+      deleted: true,
+      path: resolvedPath
+    };
+  }
+
+  async renameFile(oldPath, newName) {
+    await this._ensureConnected();
+
+    const resolvedOldPath = this._normalizePath(oldPath);
+    const newPath = path.join(path.dirname(resolvedOldPath), newName);
+
+    await this.sftp.rename(resolvedOldPath, newPath);
+
+    return {
+      oldPath: resolvedOldPath,
+      newPath: newPath,
+      name: newName
+    };
+  }
+
+  async copyFile(sourcePath, targetPath) {
+    await this._ensureConnected();
+
+    const resolvedSource = this._normalizePath(sourcePath);
+    const resolvedTarget = this._normalizePath(targetPath);
+
+    // SFTP doesn't have native copy - download then re-upload
+    const tempPath = `/tmp/kadi-copy-${Date.now()}`;
+    await this.sftp.get(resolvedSource, tempPath);
+    await this._ensureRemoteDirectory(path.dirname(resolvedTarget));
+    await this.sftp.put(tempPath, resolvedTarget);
+    await fs.unlink(tempPath);
+
+    return {
+      source: resolvedSource,
+      target: resolvedTarget,
+      success: true
+    };
+  }
+
+  async moveFile(sourcePath, targetPath) {
+    await this._ensureConnected();
+
+    const resolvedSource = this._normalizePath(sourcePath);
+    const resolvedTarget = this._normalizePath(targetPath);
+
+    await this._ensureRemoteDirectory(path.dirname(resolvedTarget));
+    await this.sftp.rename(resolvedSource, resolvedTarget);
+
+    return {
+      source: resolvedSource,
+      target: resolvedTarget,
+      success: true
+    };
+  }
+
+  // ============================================================================
+  // FOLDER OPERATIONS
+  // ============================================================================
+
+  async createFolder(remotePath) {
+    await this._ensureConnected();
+
+    const resolvedPath = this._normalizePath(remotePath);
+    await this.sftp.mkdir(resolvedPath, true); // recursive
+
+    return {
+      path: resolvedPath,
+      created: true
+    };
+  }
+
+  async deleteFolder(remotePath, recursive = false) {
+    await this._ensureConnected();
+
+    const resolvedPath = this._normalizePath(remotePath);
+
+    if (recursive) {
+      await this.sftp.rmdir(resolvedPath, true);
+    } else {
+      await this.sftp.rmdir(resolvedPath, false);
+    }
+
+    return {
+      path: resolvedPath,
+      deleted: true
+    };
+  }
+
+  async listFolders(directoryPath) {
+    await this._ensureConnected();
+
+    const resolvedPath = this._normalizePath(directoryPath);
+    const listing = await this.sftp.list(resolvedPath);
+
+    return listing
+      .filter(item => item.type === 'd' && item.name !== '.' && item.name !== '..')
+      .map(item => ({
+        name: item.name,
+        path: path.join(resolvedPath, item.name),
+        modifiedTime: new Date(item.modifyTime).toISOString()
+      }));
+  }
+
+  // ============================================================================
+  // SEARCH OPERATIONS
+  // ============================================================================
+
+  async searchFiles(query, options = {}) {
+    await this._ensureConnected();
+
+    const searchDir = this._normalizePath(options.directory || this.remoteRoot);
+
+    // Use find command via SSH for efficient searching
+    const command = `find ${searchDir} -name "${query}" -type f 2>/dev/null`;
+    const result = await this._execCommand(command);
+
+    if (!result.stdout.trim()) {
+      return [];
+    }
+
+    const filePaths = result.stdout.trim().split('\n');
+    const files = [];
+
+    for (const filePath of filePaths.slice(0, options.maxResults || 100)) {
+      try {
+        const stat = await this.sftp.stat(filePath);
+        files.push({
+          name: path.basename(filePath),
+          path: filePath,
+          size: stat.size,
+          modifiedTime: new Date(stat.modifyTime * 1000).toISOString()
+        });
+      } catch (e) {
+        // File may have been deleted, skip
+      }
+    }
+
+    return files;
+  }
+
+  // ============================================================================
+  // SSH COMMAND EXECUTION
+  // ============================================================================
+
+  async exec(command) {
+    return this._execCommand(command);
+  }
+
+  // ============================================================================
+  // HELPER METHODS
+  // ============================================================================
+
+  async _ensureConnected() {
+    if (!this.isConnected) {
+      await this.connect();
+    }
+  }
+
+  _normalizePath(inputPath) {
+    if (!inputPath || inputPath === '/') {
+      return this.remoteRoot;
+    }
+
+    if (path.isAbsolute(inputPath)) {
+      return inputPath;
+    }
+
+    return path.join(this.remoteRoot, inputPath);
+  }
+
+  async _ensureRemoteDirectory(dirPath) {
+    try {
+      await this.sftp.mkdir(dirPath, true);
+    } catch (error) {
+      if (!error.message.includes('already exists')) {
+        throw error;
+      }
+    }
+  }
+
+  async _execCommand(command) {
+    return new Promise((resolve, reject) => {
+      const conn = new Client();
+
+      conn.on('ready', () => {
+        conn.exec(command, (err, stream) => {
+          if (err) {
+            conn.end();
+            return reject(err);
+          }
+
+          let stdout = '';
+          let stderr = '';
+
+          stream.on('data', (data) => { stdout += data; });
+          stream.stderr.on('data', (data) => { stderr += data; });
+
+          stream.on('close', (code) => {
+            conn.end();
+            resolve({ stdout, stderr, code });
+          });
+        });
+      });
+
+      conn.on('error', reject);
+
+      const connConfig = {
+        host: this.host,
+        port: this.port,
+        username: this.username
+      };
+
+      if (this.password) connConfig.password = this.password;
+      if (this.privateKey) connConfig.privateKey = this.privateKey;
+
+      conn.connect(connConfig);
+    });
+  }
+
+  validateConfig() {
+    const errors = [];
+    const warnings = [];
+
+    if (!this.host) errors.push('Remote host is required');
+    if (!this.username) errors.push('Remote username is required');
+    if (!this.password && !this.privateKey && !this.privateKeyPath) {
+      errors.push('Either password or private key is required');
+    }
+
+    if (this.timeout < 5000) {
+      warnings.push('Timeout less than 5 seconds may cause connection issues');
+    }
+
+    return {
+      isValid: errors.length === 0,
+      errors,
+      warnings
+    };
+  }
+}
+
+export { RemoteProvider };