@better-webhook/cli 3.4.3 → 3.5.0

package/dist/core/template-manager.js

@@ -1,246 +0,0 @@
-import { request } from "undici";
-import { existsSync, mkdirSync, readFileSync, readdirSync, rmdirSync, unlinkSync, writeFileSync, } from "fs";
-import { join, basename } from "path";
-import { homedir } from "os";
-import { TemplatesIndexSchema, WebhookTemplateSchema, } from "../types/index.js";
-const GITHUB_RAW_BASE = "https://raw.githubusercontent.com/endalk200/better-webhook/main";
-const TEMPLATES_INDEX_URL = `${GITHUB_RAW_BASE}/templates/templates.json`;
-export class TemplateManager {
-    baseDir;
-    templatesDir;
-    cacheFile;
-    indexCache = null;
-    constructor(baseDir) {
-        this.baseDir = baseDir || join(homedir(), ".better-webhook");
-        this.templatesDir = join(this.baseDir, "templates");
-        this.cacheFile = join(this.baseDir, "templates-cache.json");
-        if (!existsSync(this.baseDir)) {
-            mkdirSync(this.baseDir, { recursive: true });
-        }
-        if (!existsSync(this.templatesDir)) {
-            mkdirSync(this.templatesDir, { recursive: true });
-        }
-    }
-    getTemplatesDir() {
-        return this.templatesDir;
-    }
-    async fetchRemoteIndex(forceRefresh = false) {
-        if (!forceRefresh && this.indexCache) {
-            return this.indexCache;
-        }
-        if (!forceRefresh && existsSync(this.cacheFile)) {
-            try {
-                const cached = JSON.parse(readFileSync(this.cacheFile, "utf-8"));
-                const cacheAge = Date.now() - (cached.cachedAt || 0);
-                if (cacheAge < 3600000) {
-                    this.indexCache = cached.index;
-                    return cached.index;
-                }
-            }
-            catch {
-            }
-        }
-        try {
-            const { statusCode, body } = await request(TEMPLATES_INDEX_URL);
-            if (statusCode !== 200) {
-                throw new Error(`HTTP ${statusCode}`);
-            }
-            const text = await body.text();
-            const json = JSON.parse(text);
-            const index = TemplatesIndexSchema.parse(json);
-            this.indexCache = index;
-            writeFileSync(this.cacheFile, JSON.stringify({ index, cachedAt: Date.now() }, null, 2));
-            return index;
-        }
-        catch (error) {
-            if (existsSync(this.cacheFile)) {
-                try {
-                    const cached = JSON.parse(readFileSync(this.cacheFile, "utf-8"));
-                    if (cached.index) {
-                        this.indexCache = cached.index;
-                        return cached.index;
-                    }
-                }
-                catch {
-                }
-            }
-            throw new Error(`Failed to fetch templates index: ${error.message}`);
-        }
-    }
-    async listRemoteTemplates(options) {
-        const index = await this.fetchRemoteIndex(!!options?.forceRefresh);
-        const localIds = new Set(this.listLocalTemplates().map((t) => t.id));
-        return index.templates.map((metadata) => ({
-            metadata,
-            isDownloaded: localIds.has(metadata.id),
-        }));
-    }
-    async downloadTemplate(templateId) {
-        const index = await this.fetchRemoteIndex();
-        const templateMeta = index.templates.find((t) => t.id === templateId);
-        if (!templateMeta) {
-            throw new Error(`Template not found: ${templateId}`);
-        }
-        const templateUrl = `${GITHUB_RAW_BASE}/templates/${templateMeta.file}`;
-        try {
-            const { statusCode, body } = await request(templateUrl);
-            if (statusCode !== 200) {
-                throw new Error(`HTTP ${statusCode}`);
-            }
-            const text = await body.text();
-            const json = JSON.parse(text);
-            const template = WebhookTemplateSchema.parse(json);
-            const providerDir = join(this.templatesDir, templateMeta.provider);
-            if (!existsSync(providerDir)) {
-                mkdirSync(providerDir, { recursive: true });
-            }
-            const fileName = `${templateId}.json`;
-            const filePath = join(providerDir, fileName);
-            const localTemplate = {
-                id: templateId,
-                metadata: templateMeta,
-                template,
-                downloadedAt: new Date().toISOString(),
-                filePath,
-            };
-            const saveData = {
-                ...template,
-                _metadata: {
-                    ...templateMeta,
-                    downloadedAt: localTemplate.downloadedAt,
-                },
-            };
-            writeFileSync(filePath, JSON.stringify(saveData, null, 2));
-            return localTemplate;
-        }
-        catch (error) {
-            throw new Error(`Failed to download template ${templateId}: ${error.message}`);
-        }
-    }
-    listLocalTemplates() {
-        const templates = [];
-        if (!existsSync(this.templatesDir)) {
-            return templates;
-        }
-        const scanDir = (dir) => {
-            const entries = readdirSync(dir, { withFileTypes: true });
-            for (const entry of entries) {
-                const fullPath = join(dir, entry.name);
-                if (entry.isDirectory()) {
-                    scanDir(fullPath);
-                }
-                else if (entry.isFile() && entry.name.endsWith(".json")) {
-                    try {
-                        const content = JSON.parse(readFileSync(fullPath, "utf-8"));
-                        const metadata = content._metadata;
-                        if (metadata) {
-                            const { _metadata, ...templateData } = content;
-                            templates.push({
-                                id: metadata.id,
-                                metadata,
-                                template: templateData,
-                                downloadedAt: metadata.downloadedAt || new Date().toISOString(),
-                                filePath: fullPath,
-                            });
-                        }
-                        else {
-                            const id = basename(entry.name, ".json");
-                            templates.push({
-                                id,
-                                metadata: {
-                                    id,
-                                    name: id,
-                                    provider: "custom",
-                                    event: "unknown",
-                                    file: entry.name,
-                                },
-                                template: content,
-                                downloadedAt: new Date().toISOString(),
-                                filePath: fullPath,
-                            });
-                        }
-                    }
-                    catch {
-                    }
-                }
-            }
-        };
-        scanDir(this.templatesDir);
-        return templates;
-    }
-    getLocalTemplate(templateId) {
-        const templates = this.listLocalTemplates();
-        return templates.find((t) => t.id === templateId) || null;
-    }
-    deleteLocalTemplate(templateId) {
-        const template = this.getLocalTemplate(templateId);
-        if (!template) {
-            return false;
-        }
-        try {
-            unlinkSync(template.filePath);
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    async searchTemplates(query) {
-        const queryLower = query.toLowerCase();
-        const remote = await this.listRemoteTemplates();
-        const local = this.listLocalTemplates();
-        const matchesMeta = (meta) => {
-            return (meta.id.toLowerCase().includes(queryLower) ||
-                meta.name.toLowerCase().includes(queryLower) ||
-                meta.provider.toLowerCase().includes(queryLower) ||
-                meta.event.toLowerCase().includes(queryLower) ||
-                (meta.description?.toLowerCase().includes(queryLower) ?? false));
-        };
-        return {
-            remote: remote.filter((t) => matchesMeta(t.metadata)),
-            local: local.filter((t) => matchesMeta(t.metadata)),
-        };
-    }
-    clearCache() {
-        this.indexCache = null;
-        if (existsSync(this.cacheFile)) {
-            unlinkSync(this.cacheFile);
-        }
-    }
-    deleteAllLocalTemplates() {
-        const templates = this.listLocalTemplates();
-        let deleted = 0;
-        for (const template of templates) {
-            try {
-                unlinkSync(template.filePath);
-                deleted++;
-            }
-            catch {
-            }
-        }
-        if (existsSync(this.templatesDir)) {
-            const entries = readdirSync(this.templatesDir, { withFileTypes: true });
-            for (const entry of entries) {
-                if (entry.isDirectory()) {
-                    const dirPath = join(this.templatesDir, entry.name);
-                    try {
-                        const contents = readdirSync(dirPath);
-                        if (contents.length === 0) {
-                            rmdirSync(dirPath);
-                        }
-                    }
-                    catch {
-                    }
-                }
-            }
-        }
-        return deleted;
-    }
-}
-let instance = null;
-export function getTemplateManager(baseDir) {
-    if (!instance) {
-        instance = new TemplateManager(baseDir);
-    }
-    return instance;
-}