@vinnyum/newsletter-sync 1.0.0

package/README.md

@@ -0,0 +1,78 @@
+# @vinnyum/newsletter-sync
+
+Automated, weekly CLI tool to download newsletters from Zoho Mail (via Composio), convert them into PDF files using Puppeteer, and upload them as sources directly into a Google NotebookLM notebook.
+
+Includes support for failure alerts sent directly to your email if a sync fails.
+
+## Installation
+
+Within the `vinnyum-tools` monorepo root:
+
+```bash
+npm install
+```
+
+To run it locally or link the bin:
+
+```bash
+npm link
+```
+
+## CLI Usage
+
+```bash
+npx newsletter-sync [options]
+```
+
+### Options
+
+| Flag | Description |
+|---|---|
+| `-c, --config <file>` | Path to a JSON configuration file |
+| `--apiKey <key>` | Composio API Key (overrides env `COMPOSIO_API_KEY`) |
+| `--zohoAccountId <id>` | Zoho Mail Account ID |
+| `--zohoFolderId <id>` | Zoho Mail Folder ID (e.g. your newsletter folder) |
+| `--senderFilter <email>` | Filter string to identify the newsletter sender |
+| `--notebookId <id>` | Google NotebookLM ID |
+| `--alertEmail <email>` | Destination email address for critical failures |
+| `--fromEmail <email>` | From email address for Zoho Mail alert emails |
+| `--processed <path>` | Path to save the processed IDs tracking list (default: `./processed_emails.json`) |
+| `--log <path>` | Path to save the execution logs (default: `./cron.log`) |
+
+## Setup Example
+
+### 1. Create a `config.json` file
+
+```json
+{
+  "composioApiKey": "your-composio-api-key",
+  "zohoAccountId": "1988858000000008002",
+  "zohoFolderId": "1988858000000009011",
+  "senderFilter": "newsletter@jamiebrindle.io",
+  "notebookId": "17c7393b-19eb-4dcc-b497-38d05976448d",
+  "alertEmail": "vinny@vinnyum.tech",
+  "fromEmail": "vinny@vinnyum.tech",
+  "processedPath": "./processed_emails.json",
+  "logPath": "./cron.log"
+}
+```
+
+### 2. Run the command with config
+
+```bash
+npx newsletter-sync --config ./config.json
+```
+
+## Scheduling on Windows
+
+To run this tool every week automatically:
+
+1. Create a batch script `run-sync.bat`:
+   ```bat
+   @echo off
+   cd /d "%~dp0"
+   npx newsletter-sync --config ./config.json
+   ```
+2. Open **Windows Task Scheduler** (`taskschd.msc`).
+3. Select **Create Basic Task** and set it to **Weekly** (e.g., Mondays at 9:00 AM).
+4. For action, choose **Start a program**, select `run-sync.bat`, and set the **Start in (optional)** field to the folder containing your `config.json` and bat script.

package/bin/cli.js

@@ -0,0 +1,90 @@
+#!/usr/bin/env node
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { parseArgs } from 'node:util';
+import { runSync } from '../index.js';
+
+const options = {
+    config: { type: 'string', short: 'c' },
+    apiKey: { type: 'string' },
+    zohoAccountId: { type: 'string' },
+    zohoFolderId: { type: 'string' },
+    senderFilter: { type: 'string' },
+    notebookId: { type: 'string' },
+    alertEmail: { type: 'string' },
+    fromEmail: { type: 'string' },
+    processed: { type: 'string' },
+    log: { type: 'string' },
+    help: { type: 'boolean', short: 'h' }
+};
+
+function printUsage() {
+    console.log(`
+Usage: npx newsletter-sync [options]
+
+Options:
+  -c, --config <file>        Path to a JSON configuration file
+  --apiKey <key>             Composio API Key (can be set as COMPOSIO_API_KEY env var)
+  --zohoAccountId <id>       Zoho Mail Account ID
+  --zohoFolderId <id>        Zoho Mail Folder ID
+  --senderFilter <filter>    Sender filter string (e.g. newsletter@sender.com)
+  --notebookId <id>          Google NotebookLM ID
+  --alertEmail <email>       Email destination for failure notifications
+  --fromEmail <email>        From email for error alert emails (must be verified in Zoho)
+  --processed <path>         Path to processed_emails.json (default: ./processed_emails.json)
+  --log <path>               Path to execution log file (default: ./cron.log)
+  -h, --help                 Show help
+`);
+}
+
+async function main() {
+    try {
+        const { values } = parseArgs({ options, allowPositionals: true });
+
+        if (values.help) {
+            printUsage();
+            process.exit(0);
+        }
+
+        let configData = {};
+
+        // 1. Read from config JSON if provided
+        if (values.config) {
+            const configPath = path.resolve(process.cwd(), values.config);
+            if (!fs.existsSync(configPath)) {
+                console.error(`❌ Error: Config file not found at ${configPath}`);
+                process.exit(1);
+            }
+            try {
+                configData = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+            } catch (e) {
+                console.error(`❌ Error: Failed to parse JSON config file: ${e.message}`);
+                process.exit(1);
+            }
+        }
+
+        // 2. Resolve merged configurations (CLI flags override config JSON)
+        const resolvedOptions = {
+            apiKey: values.apiKey || configData.composioApiKey || process.env.COMPOSIO_API_KEY,
+            zohoAccountId: values.zohoAccountId || configData.zohoAccountId,
+            zohoFolderId: values.zohoFolderId || configData.zohoFolderId,
+            senderFilter: values.senderFilter || configData.senderFilter,
+            notebookId: values.notebookId || configData.notebookId,
+            alertEmail: values.alertEmail || configData.alertEmail,
+            fromEmail: values.fromEmail || configData.fromEmail,
+            processedPath: values.processed || configData.processedPath || './processed_emails.json',
+            logPath: values.log || configData.logPath || './cron.log'
+        };
+
+        // 3. Run Sincronizador
+        await runSync(resolvedOptions);
+        process.exit(0);
+
+    } catch (err) {
+        console.error(`❌ Execution Failed: ${err.message}`);
+        process.exit(1);
+    }
+}
+
+main();

package/index.js

@@ -0,0 +1,166 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { execSync } from 'node:child_process';
+import puppeteer from 'puppeteer';
+import ComposioModule from '@composio/client';
+
+const Composio = ComposioModule.default || ComposioModule.Composio || ComposioModule;
+
+function sanitize(filename) {
+    return filename.replace(/[^a-z0-9]/gi, '_').toLowerCase();
+}
+
+export async function runSync(options = {}) {
+    const {
+        apiKey = process.env.COMPOSIO_API_KEY,
+        zohoAccountId,
+        zohoFolderId,
+        senderFilter,
+        notebookId,
+        alertEmail,
+        fromEmail,
+        processedPath = './processed_emails.json',
+        logPath = './cron.log'
+    } = options;
+
+    // Helper for logging
+    const log = (msg) => {
+        const time = new Date().toISOString();
+        const line = `[${time}] ${msg}\n`;
+        console.log(msg);
+        if (logPath) {
+            fs.appendFileSync(path.resolve(process.cwd(), logPath), line);
+        }
+    };
+
+    // Validation
+    if (!apiKey) throw new Error("Missing Composio API Key. Pass --apiKey or set COMPOSIO_API_KEY environment variable.");
+    if (!zohoAccountId) throw new Error("Missing Zoho Account ID. Pass --zohoAccountId.");
+    if (!zohoFolderId) throw new Error("Missing Zoho Folder ID. Pass --zohoFolderId.");
+    if (!senderFilter) throw new Error("Missing Sender Filter. Pass --senderFilter.");
+    if (!notebookId) throw new Error("Missing Notebook ID. Pass --notebookId.");
+
+    const processedFile = path.resolve(process.cwd(), processedPath);
+    let processed = [];
+    if (fs.existsSync(processedFile)) {
+        try {
+            processed = JSON.parse(fs.readFileSync(processedFile, 'utf8'));
+        } catch (e) {
+            log(`Warning: Failed to parse processed list, starting fresh.`);
+        }
+    }
+
+    const sendErrorEmail = async (error) => {
+        if (!alertEmail || !fromEmail) {
+            log("No alert/from email configured. Skipping email notification.");
+            return;
+        }
+        try {
+            log("Sending error email notification via Zoho Mail...");
+            const client = new Composio({ apiKey });
+            await client.tools.execute('ZOHO_MAIL_MESSAGES_SEND_EMAIL', {
+                accountId: zohoAccountId,
+                fromAddress: fromEmail,
+                toAddress: alertEmail,
+                subject: `[ALERT] Newsletter Sync Failure`,
+                content: `Newsletter Sync encountered an error:\n\n${error.stack || error.message || error}`,
+                mailFormat: 'plaintext'
+            });
+            log("Notification email sent successfully.");
+        } catch (emailErr) {
+            log(`CRITICAL: Failed to send error email: ${emailErr.message}`);
+        }
+    };
+
+    log("Starting Newsletter Sync execution...");
+    const client = new Composio({ apiKey });
+
+    try {
+        // 1. Fetch recent emails in the folder
+        log(`Fetching emails from folder ${zohoFolderId}...`);
+        const listResponse = await client.tools.execute('ZOHO_MAIL_MESSAGES_LIST_EMAILS', {
+            account_id: zohoAccountId,
+            folder_id: zohoFolderId,
+            limit: 100
+        });
+
+        if (!listResponse || !listResponse.data || !listResponse.data.data) {
+            throw new Error(`Failed to list emails: ${JSON.stringify(listResponse)}`);
+        }
+
+        const emails = listResponse.data.data;
+        log(`Retrieved ${emails.length} emails from Zoho folder.`);
+
+        // 2. Filter for new matching emails
+        const pending = emails.filter(e => {
+            const matchesSender = e.fromAddress.includes(senderFilter);
+            const alreadyProcessed = processed.includes(e.messageId);
+            return matchesSender && !alreadyProcessed;
+        });
+
+        log(`Found ${pending.length} new matching emails.`);
+        if (pending.length === 0) {
+            log("Execution completed. Nothing to sync.");
+            return;
+        }
+
+        // 3. Launch browser for PDF generation
+        log("Launching Puppeteer...");
+        const browser = await puppeteer.launch();
+        const page = await browser.newPage();
+
+        for (const email of pending) {
+            try {
+                log(`Processing: "${email.subject}" (${email.messageId})...`);
+
+                // Get content
+                const contentResponse = await client.tools.execute('ZOHO_MAIL_MESSAGES_GET_MESSAGE_CONTENT', {
+                    account_id: zohoAccountId,
+                    folder_id: zohoFolderId,
+                    message_id: email.messageId
+                });
+
+                if (!contentResponse || !contentResponse.data || !contentResponse.data.data) {
+                    throw new Error(`Failed to retrieve content for email ${email.messageId}`);
+                }
+
+                const htmlContent = contentResponse.data.data.content;
+                const pdfFilename = sanitize(email.subject) + '.pdf';
+                const pdfPath = path.resolve(process.cwd(), pdfFilename);
+
+                // Render HTML to PDF
+                log(`Generating PDF: ${pdfFilename}...`);
+                await page.setContent(htmlContent, { waitUntil: 'load', timeout: 60000 });
+                await page.pdf({ path: pdfPath, format: 'A4' });
+
+                // Upload to NotebookLM
+                log(`Uploading PDF to NotebookLM...`);
+                const cmd = `nlm source add "${notebookId}" --file "${pdfPath}" --wait`;
+                execSync(cmd, { stdio: 'inherit' });
+                log(`Successfully uploaded: ${pdfFilename}`);
+
+                // Clean up local PDF
+                if (fs.existsSync(pdfPath)) {
+                    fs.unlinkSync(pdfPath);
+                }
+
+                // Track as processed
+                processed.push(email.messageId);
+                fs.writeFileSync(processedFile, JSON.stringify(processed, null, 2));
+                log(`Logged ${email.messageId} as processed.`);
+
+            } catch (itemError) {
+                log(`Error processing email ${email.messageId}: ${itemError.message}`);
+                // Continue with other items
+            }
+        }
+
+        await browser.close();
+        log("Newsletter Sync execution finished successfully.");
+
+    } catch (error) {
+        log(`CRITICAL ERROR: ${error.stack}`);
+        await sendErrorEmail(error);
+        throw error;
+    }
+}

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@vinnyum/newsletter-sync",
+  "version": "1.0.0",
+  "description": "Weekly automated newsletter to PDF converter and Google NotebookLM source synchronizer",
+  "type": "module",
+  "main": "./index.js",
+  "bin": {
+    "newsletter-sync": "./bin/cli.js"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "@composio/client": "^0.1.0-alpha.75",
+    "puppeteer": "^25.3.0"
+  },
+  "author": {
+    "name": "Vinny Jimenez",
+    "email": "hello@vinnyum.tech",
+    "url": "https://www.linkedin.com/in/vinny-jimenez"
+  },
+  "license": "ISC",
+  "keywords": [
+    "composio",
+    "notebooklm",
+    "zoho",
+    "newsletter",
+    "pdf",
+    "synchronizer"
+  ]
+}