@streamerly/cli 0.0.1

package/dist/actions.js

@@ -0,0 +1 @@
+"use strict";

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,322 @@
+#!/usr/bin/env node
+"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 });
+const commander_1 = require("commander");
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const adm_zip_1 = __importDefault(require("adm-zip"));
+const glob_1 = __importDefault(require("glob"));
+const axios_1 = __importDefault(require("axios"));
+const form_data_1 = __importDefault(require("form-data"));
+const archiver_1 = __importDefault(require("archiver"));
+const program = new commander_1.Command();
+/**
+ * Helper zum Ausführen eines Kommandos (z.B. npx tsc ...)
+ */
+function run(cmd, args = []) {
+    return new Promise((resolve, reject) => {
+        const child = (0, child_process_1.spawn)(cmd, args, {
+            cwd: process.cwd(),
+            stdio: "inherit",
+            shell: process.platform === "win32",
+        });
+        child.on("error", (err) => reject(err));
+        child.on("close", (code) => {
+            if (code !== 0) {
+                return reject(new Error(`${cmd} exited with code ${code}`));
+            }
+            resolve();
+        });
+    });
+}
+/**
+ * streamerly create <name>
+ */
+program
+    .command("create <name>")
+    .description("Create plugin from template")
+    .action(async (name) => {
+    const cwd = process.cwd();
+    // template.zip liegt beim CLI (in dist)
+    const templateZipPath = path.resolve(__dirname, "template.zip");
+    console.info("zip path", templateZipPath);
+    if (!fs.existsSync(templateZipPath)) {
+        console.error("❌ template.zip nicht gefunden:", templateZipPath);
+        process.exit(1);
+    }
+    // Zielordner im aktuellen Projekt
+    const targetDir = path.join(cwd, name);
+    if (fs.existsSync(targetDir)) {
+        console.error(`❌ Ordner "${name}" existiert bereits!`);
+        process.exit(1);
+    }
+    fs.mkdirSync(targetDir);
+    console.log(`📁 Ordner erstellt: ${targetDir}`);
+    console.log("➡️  Template entpacken…");
+    const zip = new adm_zip_1.default(templateZipPath);
+    zip.extractAllTo(targetDir, true);
+    console.log("✔️  Entpackt.");
+    console.log(`➡️  Ersetze "MyProject" → "${name}"`);
+    const files = glob_1.default.sync("**/*", {
+        cwd: targetDir,
+        nodir: true,
+        ignore: ["**/node_modules/**", "**/.git/**", "**/dist/**"],
+    });
+    for (const file of files) {
+        const abs = path.join(targetDir, file);
+        try {
+            let content = fs.readFileSync(abs, "utf8");
+            if (content.includes("MyProject")) {
+                content = content.replace(/MyProject/g, name);
+                fs.writeFileSync(abs, content);
+            }
+        }
+        catch {
+            // Binärdateien / nicht-Text ignorieren
+        }
+    }
+    console.log("✔️  Done!");
+    console.log(`🚀 Plugin erstellt in: ${targetDir}`);
+});
+/**
+ * streamerly build
+ * -> tsc -p tsconfig.json im aktuellen Projekt
+ */
+program
+    .command("build")
+    .description("build plugin (tsc -p tsconfig.json)")
+    .action(async () => {
+    var _a;
+    try {
+        console.log("🏗  Building (tsc -p tsconfig.json) …");
+        await run("npx", ["tsc", "-p", "tsconfig.json"]);
+        console.log("✅ Build completed");
+    }
+    catch (err) {
+        console.error("❌ Build failed:", (_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : err);
+        process.exit(1);
+    }
+});
+/**
+ * streamerly pack
+ * -> ./dist im aktuellen Projekt als plugin.zip packen
+ */
+program
+    .command("pack")
+    .description("pack plugin (zip ./dist -> plugin.zip)")
+    .action(async () => {
+    const cwd = process.cwd();
+    const distDir = path.resolve(cwd, "dist");
+    const zipPath = path.resolve(cwd, "plugin.zip");
+    if (!fs.existsSync(distDir)) {
+        console.error("❌ dist Ordner nicht gefunden:", distDir);
+        process.exit(1);
+    }
+    console.log("📦 Packe dist → plugin.zip");
+    console.log("  dist:", distDir);
+    console.log("  zip :", zipPath);
+    await new Promise((resolve, reject) => {
+        const output = fs.createWriteStream(zipPath);
+        const archive = (0, archiver_1.default)("zip", { zlib: { level: 9 } });
+        output.on("close", () => {
+            console.log(`✅ plugin.zip erstellt (${archive.pointer()} bytes)`);
+            resolve();
+        });
+        output.on("error", (err) => {
+            reject(err);
+        });
+        archive.on("error", (err) => {
+            reject(err);
+        });
+        archive.pipe(output);
+        archive.directory(distDir, false);
+        archive.finalize();
+    });
+});
+/**
+ * streamerly start
+ * -> start dev servcer
+ */
+program
+    .command("start")
+    .description("start the electron server")
+    .action(async () => {
+    var _a;
+    const cwd = process.cwd();
+    const streamerlyDir = path.resolve(cwd, ".streamerly");
+    const electronZipPath = path.resolve(__dirname, "electron.zip");
+    const exists = fs.existsSync(streamerlyDir);
+    if (!exists) {
+        console.log("🆕 Kein .streamerly-Verzeichnis gefunden, erstelle Setup …");
+        if (!fs.existsSync(electronZipPath)) {
+            console.error("❌ electron.zip nicht gefunden:", electronZipPath);
+            console.error("Stelle sicher, dass dein CLI-Build electron.zip in dist enthält.");
+            process.exit(1);
+        }
+        fs.mkdirSync(streamerlyDir, { recursive: true });
+        console.log(`📁 .streamerly erstellt: ${streamerlyDir}`);
+        console.log("➡️  Entpacke electron.zip …");
+        const zip = new adm_zip_1.default(electronZipPath);
+        zip.extractAllTo(streamerlyDir, true);
+        console.log("✔️  electron.zip entpackt.");
+        const npmCmd = process.platform === "win32" ? "npm.cmd" : "npm";
+        await new Promise((resolve, reject) => {
+            const child = (0, child_process_1.spawn)(npmCmd, ["install"], {
+                cwd: streamerlyDir,
+                stdio: "inherit",
+                shell: process.platform === "win32",
+            });
+            child.on("error", reject);
+            child.on("close", (code) => {
+                if (code !== 0) {
+                    return reject(new Error(`npm install exited with code ${code}`));
+                }
+                resolve();
+            });
+        });
+        console.log("✔️  npm install.");
+    }
+    else {
+        console.log("✅ .streamerly existiert bereits, überspringe Setup.");
+    }
+    // Dependencies checken / installieren
+    const nodeModulesDir = path.join(streamerlyDir, "node_modules");
+    const electronModuleDir = path.join(nodeModulesDir, "electron");
+    const hasNodeModules = fs.existsSync(nodeModulesDir);
+    const hasElectron = fs.existsSync(electronModuleDir);
+    const hasPackageJson = fs.existsSync(path.join(streamerlyDir, "package.json"));
+    try {
+        if (!hasNodeModules || !hasElectron) {
+            console.log("📦 Installiere Abhängigkeiten im .streamerly-Verzeichnis …");
+            // wenn ein package.json vorhanden ist: normal npm install
+            // sonst fallback: nur electron installieren
+            const installCmd = process.platform === "win32" ? "npm.cmd" : "npm";
+            const installArgs = hasPackageJson
+                ? ["install"]
+                : ["install", "electron"];
+            await new Promise((resolve, reject) => {
+                const child = (0, child_process_1.spawn)(installCmd, installArgs, {
+                    cwd: streamerlyDir,
+                    stdio: "inherit",
+                    shell: process.platform === "win32",
+                });
+                child.on("error", reject);
+                child.on("close", (code) => {
+                    if (code !== 0) {
+                        return reject(new Error(`npm ${installArgs.join(" ")} exited with code ${code}`));
+                    }
+                    resolve();
+                });
+            });
+            console.log("✅ Dependencies installiert.");
+        }
+        else {
+            console.log("✅ Dependencies bereits vorhanden, überspringe npm install.");
+        }
+    }
+    catch (err) {
+        console.error("❌ Dependency-Installation fehlgeschlagen:", (_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : err);
+        process.exit(1);
+    }
+    // Electron starten
+    console.log("🚀 Starte Electron Dev Server …");
+    const npxCmd = process.platform === "win32" ? "npx.cmd" : "npx";
+    // wir geben das Promise nicht zurück, sondern lassen den Prozess laufen
+    const child = (0, child_process_1.spawn)(npxCmd, ["electron", "index.js"], {
+        cwd: streamerlyDir,
+        stdio: "inherit",
+        shell: process.platform === "win32",
+        env: {
+            ...process.env,
+            PLUGIN: "1"
+        }
+    });
+    child.on("close", (code) => {
+        if (code !== 0) {
+            console.error(`❌ Electron beendet mit Exit-Code ${code}`);
+            process.exit(code !== null && code !== void 0 ? code : 1);
+        }
+        else {
+            console.log("👋 Electron beendet.");
+        }
+    });
+});
+/**
+ * streamerly deploy
+ * -> plugin.zip aus aktuellem Projekt zu deinem Backend hochladen
+ */
+program
+    .command("deploy")
+    .description("deploy plugin (upload plugin.zip)")
+    .action(async () => {
+    var _a;
+    const cwd = process.cwd();
+    const zipPath = path.resolve(cwd, "plugin.zip");
+    if (!fs.existsSync(zipPath)) {
+        console.error("❌ plugin.zip nicht gefunden:", zipPath);
+        console.error("Tipp: erst `streamerly pack` ausführen.");
+        process.exit(1);
+    }
+    console.log("🚀 Deploy plugin:", zipPath);
+    const form = new form_data_1.default();
+    form.append("file", fs.createReadStream(zipPath), "plugin.zip");
+    try {
+        const res = await axios_1.default.post("http://localhost:8090/plugin/deploy", form, {
+            headers: {
+                ...form.getHeaders(),
+            },
+            maxBodyLength: Infinity,
+        });
+        console.log("✅ Upload erfolgreich:", res.status, res.statusText);
+        console.log(res.data);
+    }
+    catch (err) {
+        console.error("❌ Upload fehlgeschlagen");
+        if (err.response) {
+            console.error("Status:", err.response.status);
+            console.error("Body:", err.response.data);
+        }
+        else {
+            console.error((_a = err.message) !== null && _a !== void 0 ? _a : err);
+        }
+        process.exit(1);
+    }
+});
+program.parse();

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@streamerly/cli",
+  "version": "0.0.1",
+  "bin": {
+    "streamerly": "dist/index.js"
+  },
+  "license": "MIT",
+  "scripts": {
+    "build": "tsc -p tsconfig.json && npm run buildElectron && npm run packElectron && npm run packPlugin",
+    "buildElectron": "npm install --prefix ../../electron && npm run build --prefix ../../electron",
+    "packElectron": "node zipElectron.js",
+    "packPlugin": "node zipPlugin.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@types/adm-zip": "^0.5.7",
+    "@types/archiver": "^7.0.0",
+    "typescript": "^5.0.0",
+    "zip-cli": "^0.0.0"
+  },
+  "dependencies": {
+    "adm-zip": "^0.5.16",
+    "archiver": "^7.0.1",
+    "axios": "^1.13.2",
+    "commander": "^14.0.2",
+    "form-data": "^4.0.5",
+    "glob": "^13.0.0"
+  }
+}

package/src/index.ts

@@ -0,0 +1,334 @@
+#!/usr/bin/env node
+import {Command} from "commander";
+import {spawn} from "child_process";
+import * as fs from "fs";
+import * as path from "path";
+import AdmZip from "adm-zip";
+import glob from "glob";
+import axios from "axios";
+import FormData from "form-data";
+import archiver from "archiver";
+
+const program = new Command();
+
+/**
+ * Helper zum Ausführen eines Kommandos (z.B. npx tsc ...)
+ */
+function run(cmd: string, args: string[] = []): Promise<void> {
+    return new Promise((resolve, reject) => {
+        const child = spawn(cmd, args, {
+            cwd: process.cwd(),
+            stdio: "inherit",
+            shell: process.platform === "win32",
+        });
+
+        child.on("error", (err) => reject(err));
+        child.on("close", (code) => {
+            if (code !== 0) {
+                return reject(new Error(`${cmd} exited with code ${code}`));
+            }
+            resolve();
+        });
+    });
+}
+
+/**
+ * streamerly create <name>
+ */
+program
+    .command("create <name>")
+    .description("Create plugin from template")
+    .action(async (name: string) => {
+        const cwd = process.cwd();
+
+        // template.zip liegt beim CLI (in dist)
+        const templateZipPath = path.resolve(__dirname, "template.zip");
+        console.info("zip path", templateZipPath);
+
+        if (!fs.existsSync(templateZipPath)) {
+            console.error("❌ template.zip nicht gefunden:", templateZipPath);
+            process.exit(1);
+        }
+
+        // Zielordner im aktuellen Projekt
+        const targetDir = path.join(cwd, name);
+
+        if (fs.existsSync(targetDir)) {
+            console.error(`❌ Ordner "${name}" existiert bereits!`);
+            process.exit(1);
+        }
+
+        fs.mkdirSync(targetDir);
+
+        console.log(`📁 Ordner erstellt: ${targetDir}`);
+        console.log("➡️  Template entpacken…");
+
+        const zip = new AdmZip(templateZipPath);
+        zip.extractAllTo(targetDir, true);
+
+        console.log("✔️  Entpackt.");
+        console.log(`➡️  Ersetze "MyProject" → "${name}"`);
+
+        const files = glob.sync("**/*", {
+            cwd: targetDir,
+            nodir: true,
+            ignore: ["**/node_modules/**", "**/.git/**", "**/dist/**"],
+        });
+
+        for (const file of files) {
+            const abs = path.join(targetDir, file);
+
+            try {
+                let content = fs.readFileSync(abs, "utf8");
+
+                if (content.includes("MyProject")) {
+                    content = content.replace(/MyProject/g, name);
+                    fs.writeFileSync(abs, content);
+                }
+            } catch {
+                // Binärdateien / nicht-Text ignorieren
+            }
+        }
+
+        console.log("✔️  Done!");
+        console.log(`🚀 Plugin erstellt in: ${targetDir}`);
+    });
+
+/**
+ * streamerly build
+ * -> tsc -p tsconfig.json im aktuellen Projekt
+ */
+program
+    .command("build")
+    .description("build plugin (tsc -p tsconfig.json)")
+    .action(async () => {
+        try {
+            console.log("🏗  Building (tsc -p tsconfig.json) …");
+            await run("npx", ["tsc", "-p", "tsconfig.json"]);
+            console.log("✅ Build completed");
+        } catch (err: any) {
+            console.error("❌ Build failed:", err?.message ?? err);
+            process.exit(1);
+        }
+    });
+
+/**
+ * streamerly pack
+ * -> ./dist im aktuellen Projekt als plugin.zip packen
+ */
+program
+    .command("pack")
+    .description("pack plugin (zip ./dist -> plugin.zip)")
+    .action(async () => {
+        const cwd = process.cwd();
+        const distDir = path.resolve(cwd, "dist");
+        const zipPath = path.resolve(cwd, "plugin.zip");
+
+        if (!fs.existsSync(distDir)) {
+            console.error("❌ dist Ordner nicht gefunden:", distDir);
+            process.exit(1);
+        }
+
+        console.log("📦 Packe dist → plugin.zip");
+        console.log("  dist:", distDir);
+        console.log("  zip :", zipPath);
+
+        await new Promise<void>((resolve, reject) => {
+            const output = fs.createWriteStream(zipPath);
+            const archive = archiver("zip", {zlib: {level: 9}});
+
+            output.on("close", () => {
+                console.log(`✅ plugin.zip erstellt (${archive.pointer()} bytes)`);
+                resolve();
+            });
+
+            output.on("error", (err) => {
+                reject(err);
+            });
+
+            archive.on("error", (err: any) => {
+                reject(err);
+            });
+
+            archive.pipe(output);
+            archive.directory(distDir, false);
+            archive.finalize();
+        });
+    });
+
+/**
+ * streamerly start
+ * -> start dev servcer
+ */
+program
+    .command("start")
+    .description("start the electron server")
+    .action(async () => {
+        const cwd = process.cwd();
+        const streamerlyDir = path.resolve(cwd, ".streamerly");
+        const electronZipPath = path.resolve(__dirname, "electron.zip");
+
+        const exists = fs.existsSync(streamerlyDir);
+
+        if (!exists) {
+            console.log("🆕 Kein .streamerly-Verzeichnis gefunden, erstelle Setup …");
+
+            if (!fs.existsSync(electronZipPath)) {
+                console.error("❌ electron.zip nicht gefunden:", electronZipPath);
+                console.error("Stelle sicher, dass dein CLI-Build electron.zip in dist enthält.");
+                process.exit(1);
+            }
+
+            fs.mkdirSync(streamerlyDir, {recursive: true});
+
+            console.log(`📁 .streamerly erstellt: ${streamerlyDir}`);
+            console.log("➡️  Entpacke electron.zip …");
+
+            const zip = new AdmZip(electronZipPath);
+            zip.extractAllTo(streamerlyDir, true);
+
+            console.log("✔️  electron.zip entpackt.");
+
+            const npmCmd = process.platform === "win32" ? "npm.cmd" : "npm";
+
+            await new Promise<void>((resolve, reject) => {
+                const child = spawn(npmCmd, ["install"], {
+                    cwd: streamerlyDir,
+                    stdio: "inherit",
+                    shell: process.platform === "win32",
+                });
+
+                child.on("error", reject);
+                child.on("close", (code) => {
+                    if (code !== 0) {
+                        return reject(new Error(`npm install exited with code ${code}`));
+                    }
+                    resolve();
+                });
+            });
+
+            console.log("✔️  npm install.");
+        } else {
+            console.log("✅ .streamerly existiert bereits, überspringe Setup.");
+        }
+
+        // Dependencies checken / installieren
+        const nodeModulesDir = path.join(streamerlyDir, "node_modules");
+        const electronModuleDir = path.join(nodeModulesDir, "electron");
+        const hasNodeModules = fs.existsSync(nodeModulesDir);
+        const hasElectron = fs.existsSync(electronModuleDir);
+        const hasPackageJson = fs.existsSync(path.join(streamerlyDir, "package.json"));
+
+        try {
+            if (!hasNodeModules || !hasElectron) {
+                console.log("📦 Installiere Abhängigkeiten im .streamerly-Verzeichnis …");
+
+                // wenn ein package.json vorhanden ist: normal npm install
+                // sonst fallback: nur electron installieren
+                const installCmd = process.platform === "win32" ? "npm.cmd" : "npm";
+
+                const installArgs = hasPackageJson
+                    ? ["install"]
+                    : ["install", "electron"];
+
+                await new Promise<void>((resolve, reject) => {
+                    const child = spawn(installCmd, installArgs, {
+                        cwd: streamerlyDir,
+                        stdio: "inherit",
+                        shell: process.platform === "win32",
+                    });
+
+                    child.on("error", reject);
+                    child.on("close", (code) => {
+                        if (code !== 0) {
+                            return reject(new Error(`npm ${installArgs.join(" ")} exited with code ${code}`));
+                        }
+                        resolve();
+                    });
+                });
+
+                console.log("✅ Dependencies installiert.");
+            } else {
+                console.log("✅ Dependencies bereits vorhanden, überspringe npm install.");
+            }
+        } catch (err: any) {
+            console.error("❌ Dependency-Installation fehlgeschlagen:", err?.message ?? err);
+            process.exit(1);
+        }
+
+        // Electron starten
+        console.log("🚀 Starte Electron Dev Server …");
+
+        const npxCmd = process.platform === "win32" ? "npx.cmd" : "npx";
+
+        // wir geben das Promise nicht zurück, sondern lassen den Prozess laufen
+        const child = spawn(
+            npxCmd,
+            ["electron", "index.js"],
+            {
+                cwd: streamerlyDir,
+                stdio: "inherit",
+                shell: process.platform === "win32",
+
+                env: {
+                    ...process.env,
+                    PLUGIN: "1"
+                }
+            }
+        );
+
+        child.on("close", (code) => {
+            if (code !== 0) {
+                console.error(`❌ Electron beendet mit Exit-Code ${code}`);
+                process.exit(code ?? 1);
+            } else {
+                console.log("👋 Electron beendet.");
+            }
+        });
+    });
+
+/**
+ * streamerly deploy
+ * -> plugin.zip aus aktuellem Projekt zu deinem Backend hochladen
+ */
+program
+    .command("deploy")
+    .description("deploy plugin (upload plugin.zip)")
+    .action(async () => {
+        const cwd = process.cwd();
+        const zipPath = path.resolve(cwd, "plugin.zip");
+
+        if (!fs.existsSync(zipPath)) {
+            console.error("❌ plugin.zip nicht gefunden:", zipPath);
+            console.error("Tipp: erst `streamerly pack` ausführen.");
+            process.exit(1);
+        }
+
+        console.log("🚀 Deploy plugin:", zipPath);
+
+        const form = new FormData();
+        form.append("file", fs.createReadStream(zipPath), "plugin.zip");
+
+        try {
+            const res = await axios.post("http://localhost:8090/plugin/deploy", form, {
+                headers: {
+                    ...form.getHeaders(),
+                },
+                maxBodyLength: Infinity,
+            });
+
+            console.log("✅ Upload erfolgreich:", res.status, res.statusText);
+            console.log(res.data);
+        } catch (err: any) {
+            console.error("❌ Upload fehlgeschlagen");
+            if (err.response) {
+                console.error("Status:", err.response.status);
+                console.error("Body:", err.response.data);
+            } else {
+                console.error(err.message ?? err);
+            }
+            process.exit(1);
+        }
+    });
+
+program.parse();

package/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "../tsconfig.base.json",
+  "compilerOptions": {
+    "rootDir": "src",
+    "outDir": "dist"
+  },
+  "include": [
+    "src"
+  ]
+}

package/zipElectron.js

@@ -0,0 +1,12 @@
+const fs = require("fs");
+const path = require("path");
+const archiver = require("archiver");
+
+const electronDir = path.resolve(__dirname, "../../", "electron", "./dist");
+const output = fs.createWriteStream(path.resolve(__dirname, "./dist/electron.zip"));
+
+const archive = archiver("zip", {zlib: {level: 9}});
+
+archive.pipe(output);
+archive.directory(electronDir, false);
+archive.finalize();

package/zipPlugin.js

@@ -0,0 +1,22 @@
+const fs = require("fs");
+const path = require("path");
+const archiver = require("archiver");
+
+const pluginDir = path.resolve(__dirname, "../../", "plugin");
+const output = fs.createWriteStream(path.resolve(__dirname, "./dist/template.zip"));
+
+const archive = archiver("zip", {zlib: {level: 9}});
+
+archive.pipe(output);
+archive.glob("**/*", {
+    cwd: pluginDir,
+    dot: true,
+    nodir: true,
+    follow: false,
+    ignore: [
+        "**/node_modules/**",
+        "**/dist/**",
+        "**/plugin.zip"
+    ]
+});
+archive.finalize();