iobroker.script-restore 0.0.4 → 0.0.6

package/build/main.js

@@ -27,6 +27,12 @@ var path = __toESM(require("node:path"));
 var os = __toESM(require("node:os"));
 var import_node_child_process = require("node:child_process");
 var import_node_util = require("node:util");
+var ftp = __toESM(require("basic-ftp"));
+var import_node_stream = require("node:stream");
+var https = __toESM(require("node:https"));
+var http = __toESM(require("node:http"));
+var import_ssh2_sftp_client = __toESM(require("ssh2-sftp-client"));
+const SMB2 = require("@marsaud/smb2");
 const execAsync = (0, import_node_util.promisify)(import_node_child_process.exec);
 class ScriptRestore extends utils.Adapter {
   constructor(options = {}) {
@@ -39,8 +45,7 @@ class ScriptRestore extends utils.Adapter {
     this.on("unload", this.onUnload.bind(this));
   }
   onReady() {
-    const cfg = this.config;
-    this.log.info(`Script Restore ready. Backup path: ${cfg.backupPath || "/opt/iobroker/backups"}`);
+    this.log.info(`Script Restore ready. Backup path: ${this.config.backupPath || "/opt/iobroker/backups"}`);
   }
   onUnload(callback) {
     callback();
@@ -60,6 +65,63 @@ class ScriptRestore extends utils.Adapter {
         case "parseUploadedFile":
           await this.handleParseUploadedFile(obj);
           break;
+        case "getSourceConfig":
+          this.sendTo(
+            obj.from,
+            obj.command,
+            {
+              localEnabled: this.config.localEnabled !== false,
+              ftpEnabled: !!this.config.ftpEnabled,
+              smbEnabled: !!this.config.smbEnabled,
+              httpEnabled: !!this.config.httpEnabled,
+              sftpEnabled: !!this.config.sftpEnabled,
+              webdavEnabled: !!this.config.webdavEnabled
+            },
+            obj.callback
+          );
+          break;
+        case "suggestBackupPath":
+          await this.handleSuggestBackupPath(obj);
+          break;
+        case "parseHttpUrl":
+          await this.handleParseHttpUrl(obj);
+          break;
+        case "testSftp":
+          await this.handleTestSftp(obj);
+          break;
+        case "listSftpFiles":
+          await this.handleListSftpFiles(obj);
+          break;
+        case "parseSftpFile":
+          await this.handleParseSftpFile(obj);
+          break;
+        case "testWebdav":
+          await this.handleTestWebdav(obj);
+          break;
+        case "listWebdavFiles":
+          await this.handleListWebdavFiles(obj);
+          break;
+        case "parseWebdavFile":
+          await this.handleParseWebdavFile(obj);
+          break;
+        case "testFtp":
+          await this.handleTestFtp(obj);
+          break;
+        case "testSmb":
+          await this.handleTestSmb(obj);
+          break;
+        case "listFtpFiles":
+          await this.handleListFtpFiles(obj);
+          break;
+        case "parseFtpFile":
+          await this.handleParseFtpFile(obj);
+          break;
+        case "listSmbFiles":
+          await this.handleListSmbFiles(obj);
+          break;
+        case "parseSmbFile":
+          await this.handleParseSmbFile(obj);
+          break;
         default:
           this.sendTo(obj.from, obj.command, { error: "Unknown command" }, obj.callback);
       }
@@ -68,9 +130,13 @@ class ScriptRestore extends utils.Adapter {
       this.sendTo(obj.from, obj.command, { error: e.message }, obj.callback);
     }
   }
+  // ─── Local ───────────────────────────────────────────────────────────────
   async handleListLocalFiles(obj) {
-    const cfg = this.config;
-    const backupPath = cfg.backupPath || "/opt/iobroker/backups";
+    if (this.config.localEnabled === false) {
+      this.sendTo(obj.from, obj.command, { error: "Local source not enabled" }, obj.callback);
+      return;
+    }
+    const backupPath = this.config.backupPath || "/opt/iobroker/backups";
     try {
       const rawEntries = await fs.readdir(backupPath, { withFileTypes: true, encoding: "utf8" });
       const entries = rawEntries;
@@ -89,8 +155,11 @@ class ScriptRestore extends utils.Adapter {
     }
   }
   async handleParseLocalFile(obj) {
-    const cfg = this.config;
-    const backupPath = cfg.backupPath || "/opt/iobroker/backups";
+    if (this.config.localEnabled === false) {
+      this.sendTo(obj.from, obj.command, { error: "Local source not enabled" }, obj.callback);
+      return;
+    }
+    const backupPath = this.config.backupPath || "/opt/iobroker/backups";
     const msg = obj.message;
     const filename = path.basename(msg.filename);
     const filepath = path.join(backupPath, filename);
@@ -112,6 +181,193 @@ class ScriptRestore extends utils.Adapter {
       this.sendTo(obj.from, obj.command, { error: e.message }, obj.callback);
     }
   }
+  // ─── Tests ───────────────────────────────────────────────────────────────
+  async handleTestFtp(obj) {
+    const msg = obj.message;
+    const client = new ftp.Client();
+    client.ftp.verbose = false;
+    try {
+      await client.access({
+        host: msg.host,
+        port: msg.port || 21,
+        user: msg.user || "anonymous",
+        password: msg.password || "",
+        secure: msg.secure || false
+      });
+      const list = await client.list(msg.path || "/");
+      const count = list.filter((i) => i.type === ftp.FileType.File).length;
+      this.sendTo(
+        obj.from,
+        obj.command,
+        { success: true, message: `Verbunden! ${count} Datei(en) gefunden in: ${msg.path || "/"}` },
+        obj.callback
+      );
+    } catch (e) {
+      this.sendTo(obj.from, obj.command, { success: false, message: e.message }, obj.callback);
+    } finally {
+      client.close();
+    }
+  }
+  async handleTestSmb(obj) {
+    const msg = obj.message;
+    const smb = new SMB2({
+      share: `\\\\${msg.host}\\${msg.share}`,
+      username: msg.user || "",
+      password: msg.password || "",
+      domain: msg.domain || ""
+    });
+    try {
+      const files = await this.smbReaddir(smb, msg.path || "");
+      this.sendTo(
+        obj.from,
+        obj.command,
+        {
+          success: true,
+          message: `Verbunden! ${files.length} Eintr\xE4ge in: \\\\${msg.host}\\${msg.share}${msg.path ? `\\${msg.path}` : ""}`
+        },
+        obj.callback
+      );
+    } catch (e) {
+      this.sendTo(obj.from, obj.command, { success: false, message: e.message }, obj.callback);
+    } finally {
+      smb.disconnect();
+    }
+  }
+  // ─── FTP ─────────────────────────────────────────────────────────────────
+  createFtpClient() {
+    const client = new ftp.Client();
+    client.ftp.verbose = false;
+    return client;
+  }
+  async ftpConnect(client) {
+    await client.access({
+      host: this.config.ftpHost,
+      port: this.config.ftpPort || 21,
+      user: this.config.ftpUser || "anonymous",
+      password: this.config.ftpPassword || "",
+      secure: this.config.ftpSecure || false
+    });
+  }
+  async handleListFtpFiles(obj) {
+    if (!this.config.ftpEnabled) {
+      this.sendTo(obj.from, obj.command, { error: "FTP not enabled" }, obj.callback);
+      return;
+    }
+    const client = this.createFtpClient();
+    try {
+      await this.ftpConnect(client);
+      const remotePath = this.config.ftpPath || "/";
+      const list = await client.list(remotePath);
+      const files = list.filter((item) => {
+        const n = item.name;
+        return item.type === ftp.FileType.File && (n.startsWith("iobroker") || n.startsWith("javascript")) && (n.endsWith(".tar.gz") || n.endsWith(".tar") || n.endsWith(".json") || n.endsWith(".jsonl"));
+      }).map((item) => item.name).sort().reverse();
+      this.sendTo(obj.from, obj.command, { files, path: remotePath }, obj.callback);
+    } catch (e) {
+      this.sendTo(obj.from, obj.command, { error: e.message }, obj.callback);
+    } finally {
+      client.close();
+    }
+  }
+  async handleParseFtpFile(obj) {
+    if (!this.config.ftpEnabled) {
+      this.sendTo(obj.from, obj.command, { error: "FTP not enabled" }, obj.callback);
+      return;
+    }
+    const msg = obj.message;
+    const filename = path.basename(msg.filename);
+    const remotePath = path.posix.join(this.config.ftpPath || "/", filename);
+    const client = this.createFtpClient();
+    try {
+      await this.ftpConnect(client);
+      const chunks = [];
+      const writable = new import_node_stream.Writable({
+        write(chunk, _enc, cb) {
+          chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+          cb();
+        }
+      });
+      await client.downloadTo(writable, remotePath);
+      const buf = Buffer.concat(chunks);
+      const scripts = await this.parseBuffer(buf, filename);
+      this.sendTo(obj.from, obj.command, { scripts }, obj.callback);
+    } catch (e) {
+      this.sendTo(obj.from, obj.command, { error: e.message }, obj.callback);
+    } finally {
+      client.close();
+    }
+  }
+  // ─── SMB ─────────────────────────────────────────────────────────────────
+  createSmbClient() {
+    return new SMB2({
+      share: `\\\\${this.config.smbHost}\\${this.config.smbShare}`,
+      username: this.config.smbUser || "",
+      password: this.config.smbPassword || "",
+      domain: this.config.smbDomain || ""
+    });
+  }
+  smbReaddir(smb, dirPath) {
+    return new Promise((resolve, reject) => {
+      smb.readdir(dirPath, (err, files) => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve(files);
+        }
+      });
+    });
+  }
+  smbReadFile(smb, filePath) {
+    return new Promise((resolve, reject) => {
+      smb.readFile(filePath, (err, data) => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve(data);
+        }
+      });
+    });
+  }
+  async handleListSmbFiles(obj) {
+    if (!this.config.smbEnabled) {
+      this.sendTo(obj.from, obj.command, { error: "SMB not enabled" }, obj.callback);
+      return;
+    }
+    const smb = this.createSmbClient();
+    try {
+      const smbPath = this.config.smbPath || "";
+      const entries = await this.smbReaddir(smb, smbPath);
+      const files = entries.filter((n) => {
+        return (n.startsWith("iobroker") || n.startsWith("javascript")) && (n.endsWith(".tar.gz") || n.endsWith(".tar") || n.endsWith(".json") || n.endsWith(".jsonl"));
+      }).sort().reverse();
+      this.sendTo(obj.from, obj.command, { files, path: smbPath }, obj.callback);
+    } catch (e) {
+      this.sendTo(obj.from, obj.command, { error: e.message }, obj.callback);
+    } finally {
+      smb.disconnect();
+    }
+  }
+  async handleParseSmbFile(obj) {
+    if (!this.config.smbEnabled) {
+      this.sendTo(obj.from, obj.command, { error: "SMB not enabled" }, obj.callback);
+      return;
+    }
+    const msg = obj.message;
+    const filename = path.basename(msg.filename);
+    const smbPath = this.config.smbPath || "";
+    const filePath = smbPath ? `${smbPath}\\${filename}` : filename;
+    const smb = this.createSmbClient();
+    try {
+      const buf = await this.smbReadFile(smb, filePath);
+      const scripts = await this.parseBuffer(buf, filename);
+      this.sendTo(obj.from, obj.command, { scripts }, obj.callback);
+    } catch (e) {
+      this.sendTo(obj.from, obj.command, { error: e.message }, obj.callback);
+    } finally {
+      smb.disconnect();
+    }
+  }
+  // ─── Parsing ─────────────────────────────────────────────────────────────
   async parseBuffer(buf, filename) {
     const name = filename.toLowerCase();
     if (name.endsWith(".tar.gz") || name.endsWith(".tgz") || name.endsWith(".tar")) {
@@ -151,10 +407,7 @@ class ScriptRestore extends utils.Adapter {
     const walk = async (d) => {
       let entries;
       try {
-        entries = await fs.readdir(d, {
-          withFileTypes: true,
-          encoding: "utf8"
-        });
+        entries = await fs.readdir(d, { withFileTypes: true, encoding: "utf8" });
       } catch {
         return null;
       }
@@ -245,6 +498,191 @@ class ScriptRestore extends utils.Adapter {
       source: typeof c.source === "string" ? c.source : ""
     });
   }
+  // ─── Suggest backup path ─────────────────────────────────────────────────
+  async handleSuggestBackupPath(obj) {
+    var _a;
+    const candidates = ["/opt/iobroker/backups", "/root/backups"];
+    try {
+      const backupObj = await this.getForeignObjectAsync("system.adapter.backitup.0");
+      if ((_a = backupObj == null ? void 0 : backupObj.native) == null ? void 0 : _a.defaultFolder) {
+        candidates.unshift(backupObj.native.defaultFolder);
+      }
+    } catch {
+    }
+    for (const p of candidates) {
+      try {
+        await fs.access(p);
+        this.sendTo(obj.from, obj.command, { path: p }, obj.callback);
+        return;
+      } catch {
+      }
+    }
+    this.sendTo(obj.from, obj.command, { path: null }, obj.callback);
+  }
+  // ─── HTTP ────────────────────────────────────────────────────────────────
+  downloadUrl(url) {
+    return new Promise((resolve, reject) => {
+      const mod = url.startsWith("https") ? https : http;
+      mod.get(url, (res) => {
+        if (res.statusCode !== 200) {
+          reject(new Error(`HTTP ${res.statusCode}`));
+          return;
+        }
+        const chunks = [];
+        res.on("data", (c) => chunks.push(c));
+        res.on("end", () => resolve(Buffer.concat(chunks)));
+        res.on("error", reject);
+      }).on("error", reject);
+    });
+  }
+  async handleParseHttpUrl(obj) {
+    if (!this.config.httpEnabled) {
+      this.sendTo(obj.from, obj.command, { error: "HTTP not enabled" }, obj.callback);
+      return;
+    }
+    const msg = obj.message;
+    const filename = msg.url.split("/").pop() || "backup";
+    try {
+      const buf = await this.downloadUrl(msg.url);
+      const scripts = await this.parseBuffer(buf, filename);
+      this.sendTo(obj.from, obj.command, { scripts }, obj.callback);
+    } catch (e) {
+      this.sendTo(obj.from, obj.command, { error: e.message }, obj.callback);
+    }
+  }
+  // ─── SFTP ────────────────────────────────────────────────────────────────
+  async handleTestSftp(obj) {
+    const msg = obj.message;
+    const sftp = new import_ssh2_sftp_client.default();
+    try {
+      await sftp.connect({ host: msg.host, port: msg.port || 22, username: msg.user, password: msg.password });
+      const list = await sftp.list(msg.path || "/");
+      const count = list.filter((i) => i.type === "-").length;
+      this.sendTo(
+        obj.from,
+        obj.command,
+        { success: true, message: `Verbunden! ${count} Datei(en) in: ${msg.path || "/"}` },
+        obj.callback
+      );
+    } catch (e) {
+      this.sendTo(obj.from, obj.command, { success: false, message: e.message }, obj.callback);
+    } finally {
+      await sftp.end();
+    }
+  }
+  async handleListSftpFiles(obj) {
+    if (!this.config.sftpEnabled) {
+      this.sendTo(obj.from, obj.command, { error: "SFTP not enabled" }, obj.callback);
+      return;
+    }
+    const sftp = new import_ssh2_sftp_client.default();
+    try {
+      await sftp.connect({
+        host: this.config.sftpHost,
+        port: this.config.sftpPort || 22,
+        username: this.config.sftpUser,
+        password: this.config.sftpPassword
+      });
+      const remotePath = this.config.sftpPath || "/";
+      const list = await sftp.list(remotePath);
+      const files = list.filter((i) => {
+        const n = i.name;
+        return i.type === "-" && (n.startsWith("iobroker") || n.startsWith("javascript")) && (n.endsWith(".tar.gz") || n.endsWith(".tar") || n.endsWith(".json") || n.endsWith(".jsonl"));
+      }).map((i) => i.name).sort().reverse();
+      this.sendTo(obj.from, obj.command, { files, path: remotePath }, obj.callback);
+    } catch (e) {
+      this.sendTo(obj.from, obj.command, { error: e.message }, obj.callback);
+    } finally {
+      await sftp.end();
+    }
+  }
+  async handleParseSftpFile(obj) {
+    if (!this.config.sftpEnabled) {
+      this.sendTo(obj.from, obj.command, { error: "SFTP not enabled" }, obj.callback);
+      return;
+    }
+    const msg = obj.message;
+    const filename = path.basename(msg.filename);
+    const remotePath = path.posix.join(this.config.sftpPath || "/", filename);
+    const sftp = new import_ssh2_sftp_client.default();
+    try {
+      await sftp.connect({
+        host: this.config.sftpHost,
+        port: this.config.sftpPort || 22,
+        username: this.config.sftpUser,
+        password: this.config.sftpPassword
+      });
+      const buf = await sftp.get(remotePath);
+      const scripts = await this.parseBuffer(buf, filename);
+      this.sendTo(obj.from, obj.command, { scripts }, obj.callback);
+    } catch (e) {
+      this.sendTo(obj.from, obj.command, { error: e.message }, obj.callback);
+    } finally {
+      await sftp.end();
+    }
+  }
+  // ─── WebDAV ──────────────────────────────────────────────────────────────
+  async handleTestWebdav(obj) {
+    const msg = obj.message;
+    try {
+      const { createClient: createWebdavClient } = await Promise.resolve().then(() => __toESM(require("webdav")));
+      const client = createWebdavClient(msg.url, { username: msg.user, password: msg.password });
+      const list = await client.getDirectoryContents(msg.path || "/");
+      const arr = Array.isArray(list) ? list : list.data;
+      this.sendTo(
+        obj.from,
+        obj.command,
+        { success: true, message: `Verbunden! ${arr.length} Eintr\xE4ge in: ${msg.path || "/"}` },
+        obj.callback
+      );
+    } catch (e) {
+      this.sendTo(obj.from, obj.command, { success: false, message: e.message }, obj.callback);
+    }
+  }
+  async handleListWebdavFiles(obj) {
+    if (!this.config.webdavEnabled) {
+      this.sendTo(obj.from, obj.command, { error: "WebDAV not enabled" }, obj.callback);
+      return;
+    }
+    try {
+      const { createClient: createWebdavClient } = await Promise.resolve().then(() => __toESM(require("webdav")));
+      const client = createWebdavClient(this.config.webdavUrl, {
+        username: this.config.webdavUser,
+        password: this.config.webdavPassword
+      });
+      const remotePath = this.config.webdavPath || "/";
+      const list = await client.getDirectoryContents(remotePath);
+      const arr = Array.isArray(list) ? list : list.data;
+      const files = arr.filter((i) => {
+        const n = i.basename;
+        return i.type === "file" && (n.startsWith("iobroker") || n.startsWith("javascript")) && (n.endsWith(".tar.gz") || n.endsWith(".tar") || n.endsWith(".json") || n.endsWith(".jsonl"));
+      }).map((i) => i.basename).sort().reverse();
+      this.sendTo(obj.from, obj.command, { files, path: remotePath }, obj.callback);
+    } catch (e) {
+      this.sendTo(obj.from, obj.command, { error: e.message }, obj.callback);
+    }
+  }
+  async handleParseWebdavFile(obj) {
+    if (!this.config.webdavEnabled) {
+      this.sendTo(obj.from, obj.command, { error: "WebDAV not enabled" }, obj.callback);
+      return;
+    }
+    const msg = obj.message;
+    const filename = path.basename(msg.filename);
+    try {
+      const { createClient: createWebdavClient } = await Promise.resolve().then(() => __toESM(require("webdav")));
+      const client = createWebdavClient(this.config.webdavUrl, {
+        username: this.config.webdavUser,
+        password: this.config.webdavPassword
+      });
+      const remotePath = (this.config.webdavPath ? `${this.config.webdavPath}/` : "/") + filename;
+      const buf = Buffer.from(await client.getFileContents(remotePath));
+      const scripts = await this.parseBuffer(buf, filename);
+      this.sendTo(obj.from, obj.command, { scripts }, obj.callback);
+    } catch (e) {
+      this.sendTo(obj.from, obj.command, { error: e.message }, obj.callback);
+    }
+  }
 }
 if (require.main !== module) {
   module.exports = (options) => new ScriptRestore(options);