@dytsou/calendar-build 1.1.1 → 2.0.0

package/LICENSE

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2025 dytsou
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -1,32 +1,96 @@
 # Calendar App
 
-A simple calendar application that displays multiple Google Calendars in a single view.
+A simple calendar application that displays multiple calendar feeds using Open Web Calendar.
+
+## Features
+
+- Display multiple calendar feeds simultaneously
+- Dark theme with customizable styling
+- Full-height responsive design
+- URL parameters for view mode and date selection
+- Clean interface without menu buttons or navigation controls
 
 ## Setup
 
+### 1. Configure Cloudflare Worker Secrets
+
+Calendar URLs are now managed via Cloudflare Worker secrets for better security and centralized management.
+
+**Set up your Cloudflare Worker secrets:**
+
+```bash
+# Set calendar URLs (comma-separated, can be plain or fernet:// encrypted)
+wrangler secret put CALENDAR_URL
+# Enter: https://calendar.google.com/calendar/ical/example%40gmail.com/public/basic.ics,https://calendar.google.com/calendar/ical/another%40gmail.com/public/basic.ics
+
+# Set encryption key (if using fernet:// encrypted URLs)
+wrangler secret put ENCRYPTION_KEY
+# Enter your Fernet encryption key (base64url-encoded 32-byte key)
+# Generate one with: node -e "console.log(require('crypto').randomBytes(32).toString('base64').replace(/\+/g, '-').replace(/\//g, '_').replace(/=/g, ''))"
+```
+
+**Getting Google Calendar iCal URLs:**
+- Go to your Google Calendar settings
+- Find the calendar you want to share
+- Click "Integrate calendar" or "Get shareable link"
+- Copy the "Public URL to iCal format" link
+- URL-encode special characters (e.g., `@` becomes `%40`)
+
+### 2. Configure Local Development (Optional)
+
 1. Copy `.env.example` to `.env`:
+
    ```bash
    cp .env.example .env
    ```
 
-2. Edit `.env` and add your calendar sources (comma-separated):
+2. Edit `.env` and set your Cloudflare Worker URL (optional):
+
    ```
-   CALENDAR_SOURCES=calendar1,calendar2,calendar3
+   WORKER_URL=https://cal-proxy.yourdomain.com
    ```
 
-3. Build the HTML file:
-   ```bash
-   # Option 1: Using npm/pnpm (after installing)
-   pnpm install
-   pnpm run build
-   # or use the global command if installed globally
-   calendar-build
-   
-   # Option 2: Direct execution
-   node build.js
-   ```
+   If not set, defaults to `https://open-web-calendar.hosted.quelltext.eu`
+
+### 3. Build the HTML File
 
-4. Open `index.html` in your browser.
+```bash
+# Option 1: Using npm/pnpm (after installing)
+pnpm install
+pnpm run build
+# or use the global command if installed globally
+calendar-build
+
+# Option 2: Direct execution
+node scripts/build.js
+```
+
+### 4. Deploy and Open
+
+- Deploy `index.html` to your hosting service (GitHub Pages, etc.)
+- Open the deployed page in your browser
+- The Cloudflare Worker will automatically add calendar URLs from secrets to all requests
+
+## URL Parameters
+
+The calendar supports URL parameters for navigation:
+
+- **`?mode=month`** - Show month view
+- **`?mode=week`** - Show week view (default)
+- **`?mode=day`** - Show day view
+- **`?date=YYYYMMDD`** - Navigate to a specific date (e.g., `?date=20250115`)
+- **`?theme=dark`** - Force dark theme
+- **`?theme=light`** - Force light theme
+
+**Theme:** The calendar uses your browser's color scheme preference by default. You can override it using the `?theme=` URL parameter.
+
+**Examples:**
+
+- `index.html?mode=month` - Month view (uses browser theme preference)
+- `index.html?mode=week&date=20250115` - Week view for the week containing January 15, 2025
+- `index.html?mode=day&date=20250320` - Day view for March 20, 2025
+- `index.html?theme=light` - Light theme with default week view
+- `index.html?mode=month&theme=dark` - Month view with dark theme
 
 ## Install Package
 
@@ -38,6 +102,7 @@ This package is published to **both registries**:
 ### Installation from npmjs (Default - Recommended)
 
 **Global installation:**
+
 ```bash
 npm install -g @dytsou/calendar-build
 # or
@@ -45,11 +110,13 @@ pnpm install -g @dytsou/calendar-build
 ```
 
 Then use anywhere:
+
 ```bash
 calendar-build
 ```
 
 **Local installation:**
+
 ```bash
 npm install @dytsou/calendar-build
 # or
@@ -57,6 +124,7 @@ pnpm install @dytsou/calendar-build
 ```
 
 Then use:
+
 ```bash
 npx calendar-build
 # or
@@ -77,12 +145,14 @@ Create or edit `.npmrc` file in your home directory:
 ```
 
 **2. Get your GitHub token:**
+
 1. Go to https://github.com/settings/tokens
 2. Click "Generate new token" → "Generate new token (classic)"
 3. Select `read:packages` permission
 4. Copy the token and replace `YOUR_GITHUB_TOKEN` in `.npmrc`
 
 **3. Install:**
+
 ```bash
 npm install -g @dytsou/calendar-build
 # or
@@ -91,8 +161,95 @@ pnpm install -g @dytsou/calendar-build
 
 ## Development
 
-- `index.html.template` - Template file with placeholder for calendar sources
-- `build.js` - Build script that injects calendar sources from `.env`
+### Project Structure
+
+- `index.html.template` - Template file with placeholders for calendar URLs
+- `scripts/build.js` - Build script that injects calendar URLs from `.env` and updates year in LICENSE
+- `scripts/encrypt-urls.js` - Helper script to encrypt calendar URLs using Fernet
 - `.env` - Local environment file (not committed to git)
 - `.env.example` - Example environment file template
 
+### Scripts
+
+- `pnpm run build` - Build the HTML file from template
+- `pnpm format` - Format code with Prettier
+- `pnpm format:check` - Check code formatting
+
+### Build Process
+
+The build script:
+
+1. Reads `WORKER_URL` from `.env` (optional, defaults to open-web-calendar)
+2. Replaces `{{WORKER_URL}}` placeholder in the template
+3. Updates `{{YEAR}}` placeholder with current year in LICENSE and HTML
+4. Generates `index.html` ready for deployment
+
+**Note:** Calendar URLs are now managed via Cloudflare Worker secrets (`CALENDAR_URL`), not in `.env` or the HTML file. The worker automatically adds them to all calendar requests.
+
+## Cloudflare Worker Setup
+
+This project uses a Cloudflare Worker to manage calendar URLs securely. Calendar URLs are stored as Cloudflare Worker secrets, keeping them out of the HTML and GitHub secrets.
+
+### Setup Instructions
+
+1. **Copy wrangler.toml.example to wrangler.toml:**
+   ```bash
+   cp wrangler.toml.example wrangler.toml
+   ```
+   Then edit `wrangler.toml` and customize it for your environment (e.g., add custom domain routes).
+
+2. **Install Wrangler CLI:**
+   ```bash
+   npm install -g wrangler
+   # or
+   pnpm add -g wrangler
+   ```
+
+3. **Login to Cloudflare:**
+   ```bash
+   wrangler login
+   ```
+
+4. **Set Calendar URLs Secret:**
+   ```bash
+   wrangler secret put CALENDAR_URL
+   ```
+   When prompted, enter your calendar URLs (comma-separated):
+   ```
+   https://calendar.google.com/calendar/ical/example%40gmail.com/public/basic.ics,https://calendar.google.com/calendar/ical/another%40gmail.com/public/basic.ics
+   ```
+   
+   **Note:** URLs can be plain or `fernet://` encrypted. If using encrypted URLs, you'll also need to set `ENCRYPTION_KEY`.
+
+5. **Set Encryption Key Secret (if using fernet:// encrypted URLs):**
+   ```bash
+   wrangler secret put ENCRYPTION_KEY
+   ```
+   When prompted, enter your Fernet encryption key (base64url-encoded 32-byte key).
+   
+   Generate one with:
+   ```bash
+   node -e "console.log(require('crypto').randomBytes(32).toString('base64').replace(/\+/g, '-').replace(/\//g, '_').replace(/=/g, ''))"
+   ```
+
+6. **Deploy the Worker:**
+   ```bash
+   wrangler deploy
+   ```
+
+6. **Update your .env file:**
+   After deployment, update the `WORKER_URL` in your `.env` file with your worker URL:
+   ```
+   WORKER_URL=https://your-worker.your-subdomain.workers.dev
+   # or if using custom domain:
+   WORKER_URL=https://your-domain.com
+   ```
+
+7. **Rebuild your project:**
+   ```bash
+   pnpm run build
+   ```
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

package/index.html.template

@@ -1,13 +1,30 @@
 <!DOCTYPE html>
+
+<!--
+MIT License
+Copyright (c) {{YEAR}} dytsou
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+-->
+
 <html lang="zh-TW">
 
 <head>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <base href="/cal/">
     <title>My Calendar</title>
     <link rel="icon" type="image/png" href="asset/favicon.png">
 
     <style>
+        html, body {
+            height: 100%;
+            margin: 0;
+            padding: 0;
+            overflow: hidden;
+        }
+
         body {
             transition: opacity ease-in 0.2s;
         }
@@ -22,75 +39,309 @@
         iframe {
             border: solid 1px #777;
             width: 100%;
-            height: 100vh;
+            height: calc(100vh - 25px);
+        }
+
+        /* Hide error messages that might expose calendar URLs */
+        iframe {
+            /* Note: Cross-origin iframe content cannot be styled directly */
         }
     </style>
 </head>
 
 <body unresolved>
 
-    <iframe id="calendarFrame" frameborder="0" scrolling="no"></iframe>
-
-    <script>
-        const calendarBaseURL = "https://calendar.google.com/calendar/embed?";
-        const searchParams = new URLSearchParams(window.location.search);
-        const calendarParams = new URLSearchParams({
-            height: 600,
-            wkst: 1,
-            ctz: "Asia/Taipei",
-            showPrint: 0,
-            showTitle: 0,
-            showDate: 0,
-            showNav: 0,
-            showCalendars: 0,
-            showTabs: 0,
-            mode: "WEEK"
-        });
-
-        const calendars = {{CALENDAR_SOURCES}};
-
-        const defaultColor = "%23A1B3FF";
-
-        const parseDatesRange = (value) => {
-            if (!value) return null;
-            const match = /^(\d{8})\/(\d{8})$/.exec(value);
-            if (!match) return null;
-            const [, start, end] = match;
+    <iframe id="open-web-calendar" 
+        style="background:url('https://raw.githubusercontent.com/niccokunzmann/open-web-calendar/master/static/img/loaders/circular-loader.gif') center center no-repeat;"
+        sandbox="allow-scripts allow-same-origin allow-downloads"
+        allowTransparency="true" scrolling="no" 
+        frameborder="0" width="100%"></iframe>
 
-            // Basic validation to ensure chronological order.
-            if (start > end) return null;
-
-            return `${start}/${end}`;
-        };
-
-        const datesFromQuery = parseDatesRange(searchParams.get("dates"));
-        if (datesFromQuery) {
-            calendarParams.set("dates", datesFromQuery);
-        }
+    <p style="position: absolute; bottom: 2px; left: 0; right: 0; text-align: center; font-size: 9px; color: #ffffff; background-color: #000000; margin: 0; padding: 4px; pointer-events: none;">Copyright (c) {{YEAR}} dytsou</p>
 
-        const defaultMode = "WEEK";
-        const allowedModes = new Set(["MONTH", "WEEK", "AGENDA"]);
-        const requestedMode = searchParams.get("mode");
+    <script>
+        // Filter console logs to hide calendar URLs and sensitive information
+        (function() {
+            const originalError = console.error;
+            const originalLog = console.log;
+            const originalWarn = console.warn;
+            const originalInfo = console.info;
+            
+            // Patterns to detect and sanitize calendar URLs in error messages
+            const urlPatterns = [
+                /https?:\/\/[^\s"']+\.ics/gi,
+                /https?:\/\/calendar\.google\.com\/calendar\/ical\/[^\s"']+/gi,
+                /%40[^\s"']+/gi, // URL-encoded @ symbols
+                /@[^\s"']+\.ics/gi, // @ symbols in URLs
+            ];
+            
+            function sanitizeMessage(message) {
+                if (typeof message !== 'string') {
+                    return message;
+                }
+                let sanitized = message;
+                urlPatterns.forEach(pattern => {
+                    sanitized = sanitized.replace(pattern, '[Calendar URL hidden]');
+                });
+                return sanitized;
+            }
+            
+            function sanitizeArgs(args) {
+                return args.map(arg => {
+                    if (typeof arg === 'string') {
+                        return sanitizeMessage(arg);
+                    } else if (arg && typeof arg === 'object') {
+                        // Try to sanitize object string representations
+                        try {
+                            const str = JSON.stringify(arg);
+                            const sanitized = sanitizeMessage(str);
+                            if (sanitized !== str) {
+                                return JSON.parse(sanitized);
+                            }
+                        } catch (e) {
+                            // If JSON parsing fails, return original
+                        }
+                    }
+                    return arg;
+                });
+            }
+            
+            console.error = function(...args) {
+                // Check if message contains calendar URL patterns
+                const message = args.join(' ');
+                if (urlPatterns.some(pattern => pattern.test(message))) {
+                    // Replace with sanitized version
+                    const sanitized = sanitizeArgs(args);
+                    originalError.apply(console, sanitized);
+                } else {
+                    originalError.apply(console, args);
+                }
+            };
+            
+            // Helper function to check if args contain calendar info
+            function containsCalendarInfo(args) {
+                // Check string messages
+                const message = args.map(arg => {
+                    if (typeof arg === 'string') {
+                        return arg;
+                    } else if (arg && typeof arg === 'object') {
+                        try {
+                            return JSON.stringify(arg);
+                        } catch (e) {
+                            return String(arg);
+                        }
+                    }
+                    return String(arg);
+                }).join(' ');
+                
+                // Check for calendar info patterns
+                if (message.includes('Calendar Info:') || 
+                    message.includes('calendars:') ||
+                    message.includes('calendar_index:') ||
+                    message.includes('url_index:') ||
+                    message.includes('HTTPError') ||
+                    message.includes('Error in ConvertToCalendars')) {
+                    return true;
+                }
+                
+                // Check if any arg is an object with calendar-related properties
+                for (const arg of args) {
+                    if (arg && typeof arg === 'object') {
+                        const keys = Object.keys(arg);
+                        if (keys.includes('calendars') || 
+                            keys.includes('calendar_index') ||
+                            keys.includes('url_index') ||
+                            (arg.calendars && Array.isArray(arg.calendars))) {
+                            return true;
+                        }
+                    }
+                }
+                
+                return false;
+            }
+            
+            console.log = function(...args) {
+                // Filter out calendar-related logs completely
+                if (containsCalendarInfo(args) || 
+                    urlPatterns.some(pattern => {
+                        const message = args.map(a => String(a)).join(' ');
+                        return pattern.test(message);
+                    })) {
+                    // Don't log calendar info at all
+                    return;
+                }
+                originalLog.apply(console, args);
+            };
+            
+            console.warn = function(...args) {
+                const message = args.map(a => String(a)).join(' ');
+                if (urlPatterns.some(pattern => pattern.test(message))) {
+                    const sanitized = sanitizeArgs(args);
+                    originalWarn.apply(console, sanitized);
+                } else {
+                    originalWarn.apply(console, args);
+                }
+            };
+            
+            console.info = function(...args) {
+                // Filter out calendar-related info completely
+                if (containsCalendarInfo(args) || 
+                    urlPatterns.some(pattern => {
+                        const message = args.map(a => String(a)).join(' ');
+                        return pattern.test(message);
+                    })) {
+                    // Don't log calendar info at all
+                    return;
+                }
+                originalInfo.apply(console, args);
+            };
+        })();
+        
+        // Get mode from URL parameter (e.g., ?mode=month, ?mode=week, ?mode=day)
+        const urlParams = new URLSearchParams(window.location.search);
+        const requestedMode = urlParams.get('mode');
+        const requestedDate = urlParams.get('date');
+        const requestedTheme = urlParams.get('theme');
+        
+        // Valid modes and their mapping to open-web-calendar tab values
+        const validModes = ['month', 'week', 'day'];
+        const defaultMode = 'week';
+        
+        // Determine the tab to use
+        let selectedTab = defaultMode;
         if (requestedMode) {
-            const normalizedMode = requestedMode.toUpperCase();
-            if (allowedModes.has(normalizedMode)) {
-                calendarParams.set("mode", normalizedMode);
+            const normalizedMode = requestedMode.toLowerCase();
+            if (validModes.includes(normalizedMode)) {
+                selectedTab = normalizedMode;
+            }
+        }
+        
+        // Determine the theme: URL parameter takes precedence, then browser preference
+        const validThemes = ['dark', 'light'];
+        let selectedTheme;
+        if (requestedTheme) {
+            const normalizedTheme = requestedTheme.toLowerCase();
+            if (validThemes.includes(normalizedTheme)) {
+                selectedTheme = normalizedTheme;
             } else {
-                calendarParams.set("mode", defaultMode);
+                // Invalid theme parameter, fall back to browser preference
+                const prefersDark = window.matchMedia('(prefers-color-scheme: dark)').matches;
+                selectedTheme = prefersDark ? 'dark' : 'light';
+            }
+        } else {
+            // No theme parameter, use browser preference
+            const prefersDark = window.matchMedia('(prefers-color-scheme: dark)').matches;
+            selectedTheme = prefersDark ? 'dark' : 'light';
+        }
+        
+        // Parse and validate date parameter (YYYYMMDD format)
+        let selectedDate = null;
+        if (requestedDate) {
+            // Validate YYYYMMDD format
+            const dateMatch = /^(\d{4})(\d{2})(\d{2})$/.exec(requestedDate);
+            if (dateMatch) {
+                const [, year, month, day] = dateMatch;
+                // Validate the date is actually valid
+                const dateObj = new Date(parseInt(year), parseInt(month) - 1, parseInt(day));
+                if (dateObj.getFullYear() == year && 
+                    dateObj.getMonth() == parseInt(month) - 1 && 
+                    dateObj.getDate() == day) {
+                    // Convert YYYYMMDD to YYYY-MM-DD format for open-web-calendar
+                    selectedDate = `${year}-${month}-${day}`;
+                }
             }
         }
+        
+        // Calendar configuration
+        // Use Cloudflare Worker to decrypt fernet:// URLs server-side
+        // IMPORTANT: Must use /calendar.html so document.location.pathname is correct
+        // The calendar.js uses pathname.replace(/.html$/, ".json") for API calls
+        const calendarConfig = {
+            baseUrl: '{{WORKER_URL}}/calendar.html',
+            params: {
+                controls: '',
+                menu: 'false',
+                css: selectedTheme === 'dark' 
+                    ? '.dhx_scale_holder_now, .dhx_now .dhx_month_head, .dhx_now .dhx_month_body { background-color: #000000;}.dhx_month_body, .dhx_month_head, .dhx_cal_container { background-color: #000000; }.dhx_cal_navline, .dhx_cal_navline div, button[aria-label*="menu"], button[aria-label*="Menu"], .menu-button, [class*="menu"], [class*="hamburger"] { display: none !important; }'
+                    : '.dhx_cal_navline, .dhx_cal_navline div, button[aria-label*="menu"], button[aria-label*="Menu"], .menu-button, [class*="menu"], [class*="hamburger"] { display: none !important; }',
+                event_url_geo: 'https://www.google.com/maps/@{lat},{lon},{zoom}z',
+                event_url_location: 'https://www.google.com/maps/search/{location}',
+                menu_shows_calendar_names: 'false',
+                menu_shows_description: 'false',
+                menu_shows_title: 'false',
+                skin: selectedTheme,
+                start_of_week: 'su',
+                'style-event-status-cancelled': 'true',
+                'style-event-status-confirmed': 'true',
+                'style-event-status-tentative': 'true',
+                tab: selectedTab,
+                tabs: '',
+                target: '_self',
+                title: 'My Calendar'
+            }
+        };
+        
+        // Add date parameter if provided
+        if (selectedDate) {
+            calendarConfig.params.date = selectedDate;
+        }
 
-        calendars.forEach(calendar => {
-            calendarParams.append("src", calendar);
-            calendarParams.append("color", defaultColor);
-        });
+        // Build calendar URL
+        // Note: Calendar URLs are stored in Cloudflare Worker secrets
+        // The worker automatically adds them to all requests
+        const buildCalendarUrl = (config) => {
+            const url = new URL(config.baseUrl);
+            
+            // Add regular parameters
+            Object.entries(config.params).forEach(([key, value]) => {
+                if (value !== '' && value !== null) {
+                    url.searchParams.append(key, value);
+                }
+            });
+            
+            // Calendar URLs are handled by the Cloudflare Worker from secrets
+            // No need to pass them in the URL
+            
+            return url.toString();
+        };
 
-        document.getElementById("calendarFrame").src = calendarBaseURL + calendarParams.toString();
+        // Set iframe source
+        const iframe = document.getElementById('open-web-calendar');
+        iframe.src = buildCalendarUrl(calendarConfig);
+
+        // Intercept and filter error messages from iframe
+        // Note: This only works if iframe is same-origin
+        iframe.addEventListener('load', function() {
+            try {
+                // Try to access iframe content (only works if same-origin)
+                const iframeWindow = iframe.contentWindow;
+                if (iframeWindow) {
+                    // Override console methods in iframe
+                    const originalIframeError = iframeWindow.console.error;
+                    const urlPatterns = [
+                        /https?:\/\/[^\s"']+\.ics/gi,
+                        /calendar\.google\.com\/calendar\/ical\/[^\s"']+/gi,
+                        /%40[^\s"']+/gi,
+                    ];
+                    
+                    iframeWindow.console.error = function(...args) {
+                        const message = args.join(' ');
+                        if (urlPatterns.some(pattern => pattern.test(message))) {
+                            // Don't log errors with calendar URLs
+                            return;
+                        }
+                        originalIframeError.apply(iframeWindow.console, args);
+                    };
+                }
+            } catch (e) {
+                // Cross-origin restriction - can't access iframe content
+                // Console filtering on parent page will still work
+            }
+        });
 
         window.onload = () => document.body.removeAttribute('unresolved');
     </script>
 
 </body>
 
-</html>
-
+</html>

package/package.json

@@ -1,19 +1,16 @@
 {
   "name": "@dytsou/calendar-build",
-  "version": "1.1.1",
+  "version": "2.0.0",
   "description": "Build script for calendar HTML from template and environment variables",
-  "main": "build.js",
+  "main": "scripts/build.js",
   "bin": {
-    "calendar-build": "build.js"
+    "calendar-build": "scripts/build.js"
   },
   "files": [
-    "build.js",
+    "scripts/build.js",
     "index.html.template",
     "README.md"
   ],
-  "scripts": {
-    "build": "node build.js"
-  },
   "keywords": [
     "calendar",
     "build",
@@ -31,5 +28,19 @@
   "homepage": "https://github.com/dytsou/cal#readme",
   "engines": {
     "node": ">=12.0.0"
+  },
+  "devDependencies": {
+    "browserify": "^17.0.1",
+    "prettier": "^3.7.4",
+    "wrangler": "4.54.0"
+  },
+  "dependencies": {
+    "fernet": "^0.3.3",
+    "glob": "13.0.0"
+  },
+  "scripts": {
+    "build": "node scripts/build.js",
+    "format": "prettier --write .",
+    "format:check": "prettier --check ."
   }
 }

package/scripts/build.js

@@ -0,0 +1,192 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const Fernet = require('fernet');
+const { execSync } = require('child_process');
+
+// Read template HTML
+const templatePath = path.join(__dirname, '..', 'index.html.template');
+if (!fs.existsSync(templatePath)) {
+  console.error('Error: index.html.template not found');
+  process.exit(1);
+}
+
+let html = fs.readFileSync(templatePath, 'utf-8');
+
+// Always check for placeholders that need replacement
+const hasPlaceholders = html.includes('{{CALENDAR_SOURCES}}') || html.includes('{{CALENDAR_URLS}}');
+const needsWorkerUrl = html.includes('{{WORKER_URL}}');
+let workerUrl = '';
+
+// Always read .env for WORKER_URL if needed
+if (needsWorkerUrl || hasPlaceholders) {
+  const envPath = path.join(__dirname, '..', '.env');
+  if (hasPlaceholders && !fs.existsSync(envPath)) {
+    console.error('Error: .env file not found (required for placeholders)');
+    process.exit(1);
+  }
+  
+  if (fs.existsSync(envPath)) {
+    const envContent = fs.readFileSync(envPath, 'utf-8');
+    const envLines = envContent.split('\n');
+
+    // Parse environment variables
+    let calendarSources = [];
+    let calendarUrls = [];
+
+    for (const line of envLines) {
+      if (line.startsWith('CALENDAR_SOURCES=')) {
+        const value = line.substring('CALENDAR_SOURCES='.length).trim();
+        calendarSources = value
+          .split(',')
+          .map(s => s.trim())
+          .filter(s => s);
+      } else if (line.startsWith('CALENDAR_URL=')) {
+        const value = line.substring('CALENDAR_URL='.length).trim();
+        // Support both single URL and comma-separated multiple URLs
+        const urls = value
+          .split(',')
+          .map(s => s.trim())
+          .filter(s => s);
+        calendarUrls.push(...urls);
+      } else if (line.startsWith('WORKER_URL=')) {
+        workerUrl = line.substring('WORKER_URL='.length).trim();
+      }
+    }
+  }
+}
+
+if (hasPlaceholders) {
+
+  // Replace CALENDAR_SOURCES placeholder
+  if (html.includes('{{CALENDAR_SOURCES}}')) {
+    if (calendarSources.length === 0) {
+      console.error('Error: No calendar sources found in .env file');
+      process.exit(1);
+    }
+
+    const calendarArrayCode =
+      '[\n' + calendarSources.map(cal => `            "${cal}"`).join(',\n') + '\n        ]';
+
+    html = html.replace('{{CALENDAR_SOURCES}}', calendarArrayCode);
+    console.log(
+      `✓ Replaced {{CALENDAR_SOURCES}} with ${calendarSources.length} calendar source(s)`
+    );
+  }
+
+  // Replace CALENDAR_URLS placeholder
+  if (html.includes('{{CALENDAR_URLS}}')) {
+    if (calendarUrls.length === 0) {
+      console.error('Error: CALENDAR_URL not found in .env file');
+      process.exit(1);
+    }
+
+    // Get encryption settings from .env
+    let encryptionMethod = '';
+    let encryptionKey = '';
+
+    for (const line of envLines) {
+      if (line.startsWith('ENCRYPTION_METHOD=')) {
+        encryptionMethod = line.substring('ENCRYPTION_METHOD='.length).trim().toLowerCase();
+      } else if (line.startsWith('ENCRYPTION_KEY=')) {
+        encryptionKey = line.substring('ENCRYPTION_KEY='.length).trim();
+      }
+    }
+
+    let calendarUrlsArrayCode;
+
+    if (encryptionMethod === 'fernet' && encryptionKey) {
+      // Use Fernet encryption
+      try {
+        const secret = new Fernet.Secret(encryptionKey);
+        const token = new Fernet.Token({
+          secret: secret,
+          ttl: 0, // No expiration
+        });
+
+        const encryptedUrls = calendarUrls.map(url => {
+          const encrypted = token.encode(url);
+          // Format as fernet:// protocol URL
+          return `fernet://${encrypted}`;
+        });
+
+        calendarUrlsArrayCode =
+          '[\n' + encryptedUrls.map(url => `            "${url}"`).join(',\n') + '\n        ]';
+
+        html = html.replace('{{ENCRYPTION_METHOD}}', 'fernet');
+        html = html.replace('{{ENCRYPTION_KEY}}', encryptionKey);
+        console.log(
+          `✓ Replaced {{CALENDAR_URLS}} with ${encryptedUrls.length} Fernet-encrypted calendar URL(s)`
+        );
+        
+        // Output encrypted URLs for copying to .env
+        console.log('\n📋 Encrypted URLs (for .env file):');
+        console.log('CALENDAR_URL_ENCRYPTED=' + encryptedUrls.join(','));
+        console.log('\nOr individually:');
+        encryptedUrls.forEach((encrypted, index) => {
+          console.log(`# URL ${index + 1}: ${encrypted}`);
+        });
+      } catch (error) {
+        console.error('Error encrypting with Fernet:', error.message);
+        process.exit(1);
+      }
+    } else {
+      // No encryption - plain URLs
+      calendarUrlsArrayCode =
+        '[\n' + calendarUrls.map(url => `            "${url}"`).join(',\n') + '\n        ]';
+      html = html.replace('{{ENCRYPTION_METHOD}}', 'none');
+      html = html.replace('{{ENCRYPTION_KEY}}', '');
+      html = html.replace('{{WORKER_URL}}', 'https://open-web-calendar.hosted.quelltext.eu/calendar.html');
+      console.log(
+        `✓ Replaced {{CALENDAR_URLS}} with ${calendarUrls.length} calendar URL(s) (no encryption)`
+      );
+    }
+
+    html = html.replace('{{CALENDAR_URLS}}', calendarUrlsArrayCode);
+    
+    // Remove encryption key placeholder (not needed with Worker)
+    html = html.replace('{{ENCRYPTION_KEY}}', '');
+    
+    // Clean up fernet-bundle.js if it exists (no longer needed with Worker)
+    const bundleFile = path.join(__dirname, '..', 'fernet-bundle.js');
+    if (fs.existsSync(bundleFile)) {
+      fs.unlinkSync(bundleFile);
+      console.log('✓ Removed fernet-bundle.js (using Cloudflare Worker instead)');
+    }
+  }
+}
+
+// Always replace WORKER_URL placeholder if it exists (regardless of other placeholders)
+if (html.includes('{{WORKER_URL}}')) {
+  const finalWorkerUrl = workerUrl || process.env.WORKER_URL || 'https://open-web-calendar.hosted.quelltext.eu';
+  html = html.replace('{{WORKER_URL}}', finalWorkerUrl);
+  if (finalWorkerUrl !== 'https://open-web-calendar.hosted.quelltext.eu') {
+    console.log(`✓ Using Cloudflare Worker: ${finalWorkerUrl}`);
+  } else {
+    console.log('✓ Replaced {{WORKER_URL}} with default open-web-calendar URL');
+  }
+}
+
+// Get current year for placeholders
+const currentYear = new Date().getFullYear().toString();
+
+// Replace {{YEAR}} placeholder in HTML template
+if (html.includes('{{YEAR}}')) {
+  html = html.replace(/\{\{YEAR\}\}/g, currentYear);
+}
+
+// Write built HTML
+const outputPath = path.join(__dirname, '..', 'index.html');
+fs.writeFileSync(outputPath, html, 'utf-8');
+
+// Update LICENSE file with current year
+const licensePath = path.join(__dirname, '..', 'LICENSE');
+if (fs.existsSync(licensePath)) {
+  let licenseContent = fs.readFileSync(licensePath, 'utf-8');
+  if (licenseContent.includes('{{YEAR}}')) {
+    licenseContent = licenseContent.replace(/\{\{YEAR\}\}/g, currentYear);
+    fs.writeFileSync(licensePath, licenseContent, 'utf-8');
+    console.log(`✓ Updated LICENSE with year ${currentYear}`);
+  }
+}

package/build.js

@@ -1,53 +0,0 @@
-#!/usr/bin/env node
-
-const fs = require('fs');
-const path = require('path');
-
-// Read .env file
-const envPath = path.join(__dirname, '.env');
-if (!fs.existsSync(envPath)) {
-  console.error('Error: .env file not found');
-  process.exit(1);
-}
-
-const envContent = fs.readFileSync(envPath, 'utf-8');
-const envLines = envContent.split('\n');
-
-// Parse CALENDAR_SOURCES from .env
-let calendarSources = [];
-for (const line of envLines) {
-  if (line.startsWith('CALENDAR_SOURCES=')) {
-    const value = line.substring('CALENDAR_SOURCES='.length).trim();
-    calendarSources = value.split(',').map(s => s.trim()).filter(s => s);
-    break;
-  }
-}
-
-if (calendarSources.length === 0) {
-  console.error('Error: No calendar sources found in .env file');
-  process.exit(1);
-}
-
-// Read template HTML
-const templatePath = path.join(__dirname, 'index.html.template');
-if (!fs.existsSync(templatePath)) {
-  console.error('Error: index.html.template not found');
-  process.exit(1);
-}
-
-let html = fs.readFileSync(templatePath, 'utf-8');
-
-// Generate calendar array as JavaScript code
-const calendarArrayCode = '[\n' + calendarSources
-  .map(cal => `            "${cal}"`)
-  .join(',\n') + '\n        ]';
-
-// Replace placeholder
-html = html.replace('{{CALENDAR_SOURCES}}', calendarArrayCode);
-
-// Write built HTML
-const outputPath = path.join(__dirname, 'index.html');
-fs.writeFileSync(outputPath, html, 'utf-8');
-
-console.log(`✓ Built index.html with ${calendarSources.length} calendar source(s)`);
-