mediaguru 1.0.0

package/dist/core/pdf/index.d.ts

@@ -0,0 +1,34 @@
+export interface PdfEngineOptions {
+    outputDir?: string;
+    outputPath?: string;
+}
+export declare class PdfEngine {
+    /**
+     * Compiles Markdown text/file to PDF using Playwright
+     */
+    static markdownToPdf(mdPath: string, opts?: PdfEngineOptions): Promise<string>;
+    /**
+     * Compiles HTML file to PDF using Playwright
+     */
+    static htmlToPdf(htmlPath: string, opts?: PdfEngineOptions): Promise<string>;
+    /**
+     * Helper to render HTML to PDF via Playwright
+     */
+    private static htmlStringToPdf;
+    /**
+     * Merges multiple PDF files into a single PDF
+     */
+    static merge(pdfPaths: string[], opts?: PdfEngineOptions): Promise<string>;
+    /**
+     * Splits a single PDF into individual pages
+     */
+    static split(pdfPath: string, opts?: PdfEngineOptions): Promise<string[]>;
+    /**
+     * Extracts text from a PDF file using pdf-parse
+     */
+    static extractText(pdfPath: string): Promise<string>;
+    /**
+     * Compresses PDF using pdf-lib optimize options
+     */
+    static compress(pdfPath: string, opts?: PdfEngineOptions): Promise<string>;
+}

package/dist/core/pdf/index.js

@@ -0,0 +1,121 @@
+import fs from 'fs';
+import path from 'path';
+import { PDFDocument } from 'pdf-lib';
+// @ts-ignore
+import pdfParse from 'pdf-parse';
+import { chromium } from 'playwright';
+import { marked } from 'marked';
+import { getHtmlForPdf } from '../../utils/templates.js';
+import { resolveOutputPath } from '../../utils/file.js';
+export class PdfEngine {
+    /**
+     * Compiles Markdown text/file to PDF using Playwright
+     */
+    static async markdownToPdf(mdPath, opts = {}) {
+        const mdContent = fs.readFileSync(mdPath, 'utf-8');
+        const htmlBody = await marked.parse(mdContent);
+        const fullHtml = getHtmlForPdf(htmlBody);
+        const outDir = opts.outputDir || './output';
+        const targetPath = opts.outputPath || resolveOutputPath(mdPath, outDir, 'pdf');
+        await this.htmlStringToPdf(fullHtml, targetPath);
+        return targetPath;
+    }
+    /**
+     * Compiles HTML file to PDF using Playwright
+     */
+    static async htmlToPdf(htmlPath, opts = {}) {
+        const htmlContent = fs.readFileSync(htmlPath, 'utf-8');
+        const outDir = opts.outputDir || './output';
+        const targetPath = opts.outputPath || resolveOutputPath(htmlPath, outDir, 'pdf');
+        await this.htmlStringToPdf(htmlContent, targetPath);
+        return targetPath;
+    }
+    /**
+     * Helper to render HTML to PDF via Playwright
+     */
+    static async htmlStringToPdf(html, outputPath) {
+        const browser = await chromium.launch({ headless: true });
+        try {
+            const page = await browser.newPage();
+            await page.setContent(html, { waitUntil: 'load' });
+            await page.pdf({
+                path: outputPath,
+                format: 'A4',
+                margin: {
+                    top: '20mm',
+                    right: '20mm',
+                    bottom: '20mm',
+                    left: '20mm',
+                },
+                printBackground: true,
+            });
+        }
+        finally {
+            await browser.close();
+        }
+    }
+    /**
+     * Merges multiple PDF files into a single PDF
+     */
+    static async merge(pdfPaths, opts = {}) {
+        if (pdfPaths.length < 2) {
+            throw new Error('At least 2 PDF files are required for merging.');
+        }
+        const mergedDoc = await PDFDocument.create();
+        for (const pdfPath of pdfPaths) {
+            const pdfBytes = fs.readFileSync(pdfPath);
+            const doc = await PDFDocument.load(pdfBytes);
+            const copiedPages = await mergedDoc.copyPages(doc, doc.getPageIndices());
+            copiedPages.forEach((page) => mergedDoc.addPage(page));
+        }
+        const mergedBytes = await mergedDoc.save();
+        const outDir = opts.outputDir || './output';
+        const targetPath = opts.outputPath || path.join(outDir, 'merged.pdf');
+        fs.writeFileSync(targetPath, mergedBytes);
+        return targetPath;
+    }
+    /**
+     * Splits a single PDF into individual pages
+     */
+    static async split(pdfPath, opts = {}) {
+        const pdfBytes = fs.readFileSync(pdfPath);
+        const mainDoc = await PDFDocument.load(pdfBytes);
+        const totalPages = mainDoc.getPageCount();
+        const createdPaths = [];
+        const outDir = opts.outputDir || './output';
+        const baseName = path.basename(pdfPath, path.extname(pdfPath));
+        for (let i = 0; i < totalPages; i++) {
+            const pageDoc = await PDFDocument.create();
+            const [copiedPage] = await pageDoc.copyPages(mainDoc, [i]);
+            pageDoc.addPage(copiedPage);
+            const pageBytes = await pageDoc.save();
+            const pagePath = path.join(outDir, `${baseName}_page_${i + 1}.pdf`);
+            fs.writeFileSync(pagePath, pageBytes);
+            createdPaths.push(pagePath);
+        }
+        return createdPaths;
+    }
+    /**
+     * Extracts text from a PDF file using pdf-parse
+     */
+    static async extractText(pdfPath) {
+        const pdfBuffer = fs.readFileSync(pdfPath);
+        const data = await pdfParse(pdfBuffer);
+        return data.text;
+    }
+    /**
+     * Compresses PDF using pdf-lib optimize options
+     */
+    static async compress(pdfPath, opts = {}) {
+        const pdfBytes = fs.readFileSync(pdfPath);
+        const doc = await PDFDocument.load(pdfBytes);
+        // Save with compression & minification
+        const compressedBytes = await doc.save({
+            useObjectStreams: true,
+        });
+        const outDir = opts.outputDir || './output';
+        const targetPath = opts.outputPath || resolveOutputPath(pdfPath, outDir, 'pdf', '_compressed');
+        fs.writeFileSync(targetPath, compressedBytes);
+        return targetPath;
+    }
+}

package/dist/core/qr/index.d.ts

@@ -0,0 +1,12 @@
+export interface QrEngineOptions {
+    outputDir?: string;
+    outputPath?: string;
+    svg?: boolean;
+    size?: number;
+}
+export declare class QrEngine {
+    /**
+     * Generates a QR Code image or vector file from text/url
+     */
+    static generate(text: string, opts?: QrEngineOptions): Promise<string>;
+}

package/dist/core/qr/index.js

@@ -0,0 +1,37 @@
+import fs from 'fs';
+import path from 'path';
+import QRCode from 'qrcode';
+import { ConfigManager } from '../config/index.js';
+export class QrEngine {
+    /**
+     * Generates a QR Code image or vector file from text/url
+     */
+    static async generate(text, opts = {}) {
+        const outDir = opts.outputDir || ConfigManager.getOutputFolder();
+        const isSvg = opts.svg || false;
+        const size = opts.size || 300;
+        const ext = isSvg ? 'svg' : 'png';
+        const targetPath = opts.outputPath || path.join(outDir, `qr.${ext}`);
+        // Ensure output dir exists
+        if (!fs.existsSync(outDir)) {
+            fs.mkdirSync(outDir, { recursive: true });
+        }
+        if (isSvg) {
+            // Generate SVG as a string and write to file
+            const svgString = await QRCode.toString(text, {
+                type: 'svg',
+                width: size,
+                margin: 2,
+            });
+            fs.writeFileSync(targetPath, svgString, 'utf-8');
+        }
+        else {
+            // Generate PNG binary directly to file
+            await QRCode.toFile(targetPath, text, {
+                width: size,
+                margin: 2,
+            });
+        }
+        return targetPath;
+    }
+}

package/dist/core/screenshot/index.d.ts

@@ -0,0 +1,12 @@
+export interface ScreenshotOptions {
+    outputDir?: string;
+    outputPath?: string;
+    fullPage?: boolean;
+    mobile?: boolean;
+}
+export declare class ScreenshotEngine {
+    /**
+     * Capture a screenshot of a website using Playwright
+     */
+    static capture(url: string, opts?: ScreenshotOptions): Promise<string>;
+}

package/dist/core/screenshot/index.js

@@ -0,0 +1,46 @@
+import fs from 'fs';
+import path from 'path';
+import { chromium, devices } from 'playwright';
+import { ConfigManager } from '../config/index.js';
+export class ScreenshotEngine {
+    /**
+     * Capture a screenshot of a website using Playwright
+     */
+    static async capture(url, opts = {}) {
+        const outDir = opts.outputDir || ConfigManager.getOutputFolder();
+        const config = ConfigManager.load();
+        // Parse resolution from config (e.g. "1280x720")
+        let width = 1280;
+        let height = 720;
+        if (config.screenshotResolution && config.screenshotResolution.includes('x')) {
+            const parts = config.screenshotResolution.split('x');
+            width = parseInt(parts[0], 10) || 1280;
+            height = parseInt(parts[1], 10) || 720;
+        }
+        const domainName = new URL(url).hostname.replace('www.', '');
+        const filename = `screenshot_${domainName}_${opts.mobile ? 'mobile' : 'desktop'}.png`;
+        const targetPath = opts.outputPath || path.join(outDir, filename);
+        if (!fs.existsSync(outDir)) {
+            fs.mkdirSync(outDir, { recursive: true });
+        }
+        const browser = await chromium.launch({ headless: true });
+        try {
+            // Use iPhone 13 device profile for mobile emulation, or regular desktop viewport
+            const contextOptions = opts.mobile
+                ? { ...devices['iPhone 13'] }
+                : { viewport: { width, height } };
+            const context = await browser.newContext(contextOptions);
+            const page = await context.newPage();
+            // Navigate to the target page and wait until network is quiet
+            await page.goto(url, { waitUntil: 'networkidle', timeout: 30000 });
+            await page.screenshot({
+                path: targetPath,
+                fullPage: opts.fullPage || false,
+            });
+        }
+        finally {
+            await browser.close();
+        }
+        return targetPath;
+    }
+}

package/dist/core/server/index.d.ts

@@ -0,0 +1,5 @@
+export declare class RestApiServer {
+    private server;
+    start(port: number): Promise<void>;
+    stop(): void;
+}

package/dist/core/server/index.js

@@ -0,0 +1,101 @@
+import http from 'http';
+import url from 'url';
+import fs from 'fs';
+import path from 'path';
+import chalk from 'chalk';
+import { ConfigManager } from '../config/index.js';
+import { QrEngine } from '../qr/index.js';
+import { ScreenshotEngine } from '../screenshot/index.js';
+export class RestApiServer {
+    server = null;
+    start(port) {
+        return new Promise((resolve, reject) => {
+            this.server = http.createServer(async (req, res) => {
+                const parsedUrl = url.parse(req.url || '', true);
+                const pathname = parsedUrl.pathname;
+                const query = parsedUrl.query;
+                // CORS Headers
+                res.setHeader('Access-Control-Allow-Origin', '*');
+                res.setHeader('Access-Control-Allow-Methods', 'GET, OPTIONS');
+                res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+                if (req.method === 'OPTIONS') {
+                    res.writeHead(204);
+                    res.end();
+                    return;
+                }
+                console.log(`[REST Server] ${chalk.green(req.method)} ${req.url}`);
+                try {
+                    if (pathname === '/api/config') {
+                        const config = ConfigManager.load();
+                        res.writeHead(200, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify(config, null, 2));
+                        return;
+                    }
+                    if (pathname === '/api/qr') {
+                        const text = query.text || 'https://kontyra.com';
+                        const size = parseInt(query.size, 10) || 300;
+                        // Generate temporary QR
+                        const tempDir = './temp_server_files';
+                        const qrPath = await QrEngine.generate(text, {
+                            outputDir: tempDir,
+                            outputPath: path.join(tempDir, `qr_${Date.now()}.png`),
+                            size,
+                        });
+                        const imgBytes = fs.readFileSync(qrPath);
+                        res.writeHead(200, { 'Content-Type': 'image/png' });
+                        res.end(imgBytes);
+                        // Clean up temp file
+                        fs.unlinkSync(qrPath);
+                        return;
+                    }
+                    if (pathname === '/api/screenshot') {
+                        const siteUrl = query.url;
+                        if (!siteUrl) {
+                            res.writeHead(400, { 'Content-Type': 'application/json' });
+                            res.end(JSON.stringify({ error: 'Missing required "url" parameter.' }));
+                            return;
+                        }
+                        const mobile = query.mobile === 'true';
+                        const tempDir = './temp_server_files';
+                        const scrPath = await ScreenshotEngine.capture(siteUrl, {
+                            outputDir: tempDir,
+                            outputPath: path.join(tempDir, `scr_${Date.now()}.png`),
+                            mobile,
+                        });
+                        const imgBytes = fs.readFileSync(scrPath);
+                        res.writeHead(200, { 'Content-Type': 'image/png' });
+                        res.end(imgBytes);
+                        // Clean up temp file
+                        fs.unlinkSync(scrPath);
+                        return;
+                    }
+                    // 404 Route
+                    res.writeHead(404, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ error: 'Endpoint not found. Exposing: /api/config, /api/qr, /api/screenshot' }));
+                }
+                catch (err) {
+                    console.error('[REST Server] Error handling request:', err);
+                    res.writeHead(500, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ error: err.message || 'Internal Server Error' }));
+                }
+            });
+            this.server.listen(port, () => {
+                console.log(chalk.bold.green(`\n[REST Server] Running at http://localhost:${port}/`));
+                console.log(chalk.dim(`Exposed endpoints:`));
+                console.log(`  - ${chalk.cyan(`GET http://localhost:${port}/api/config`)}`);
+                console.log(`  - ${chalk.cyan(`GET http://localhost:${port}/api/qr?text=...&size=...`)}`);
+                console.log(`  - ${chalk.cyan(`GET http://localhost:${port}/api/screenshot?url=...&mobile=...`)}\n`);
+                resolve();
+            });
+            this.server.on('error', (err) => {
+                reject(err);
+            });
+        });
+    }
+    stop() {
+        if (this.server) {
+            this.server.close();
+            console.log(chalk.yellow('[REST Server] Stopped.'));
+        }
+    }
+}

package/dist/core/text2img/index.d.ts

@@ -0,0 +1,14 @@
+export interface Text2ImgOptions {
+    theme?: 'dark' | 'light' | 'glass';
+    type?: 'quote' | 'banner' | 'poster' | 'social';
+    title?: string;
+    author?: string;
+    outputDir?: string;
+    outputPath?: string;
+}
+export declare class Text2ImgEngine {
+    /**
+     * Generates a beautifully-designed social banner, quote, poster, or card from text.
+     */
+    static generate(text: string, opts?: Text2ImgOptions): Promise<string>;
+}

package/dist/core/text2img/index.js

@@ -0,0 +1,64 @@
+import fs from 'fs';
+import path from 'path';
+import { chromium } from 'playwright';
+import { getHtmlForSocialCard } from '../../utils/templates.js';
+import { ConfigManager } from '../config/index.js';
+export class Text2ImgEngine {
+    /**
+     * Generates a beautifully-designed social banner, quote, poster, or card from text.
+     */
+    static async generate(text, opts = {}) {
+        const theme = opts.theme || 'dark';
+        const type = opts.type || 'social';
+        const title = opts.title || '';
+        const author = opts.author || '';
+        const htmlContent = getHtmlForSocialCard({
+            text,
+            theme,
+            type,
+            title,
+            author,
+        });
+        // Define resolutions for screenshot viewports
+        let width = 1200;
+        let height = 630;
+        if (type === 'quote') {
+            width = 800;
+            height = 800;
+        }
+        else if (type === 'poster') {
+            width = 800;
+            height = 1200;
+        }
+        else if (type === 'banner') {
+            width = 1200;
+            height = 400;
+        }
+        // Slugify text to create a clean filename
+        const slug = text
+            .toLowerCase()
+            .replace(/[^a-z0-9]+/g, '_')
+            .substring(0, 20) || 'social_card';
+        const outDir = opts.outputDir || ConfigManager.getOutputFolder();
+        const targetPath = opts.outputPath || path.join(outDir, `${slug}.png`);
+        if (!fs.existsSync(outDir)) {
+            fs.mkdirSync(outDir, { recursive: true });
+        }
+        const browser = await chromium.launch({ headless: true });
+        try {
+            const page = await browser.newPage();
+            await page.setViewportSize({ width, height });
+            await page.setContent(htmlContent, { waitUntil: 'load' });
+            // Wait for any external font resources to load
+            await page.evaluate(() => document.fonts.ready);
+            await page.screenshot({
+                path: targetPath,
+                type: 'png',
+            });
+        }
+        finally {
+            await browser.close();
+        }
+        return targetPath;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export {};