tunecamp 1.0.0

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "tunecamp",
+  "version": "1.0.0",
+  "description": "A modern static site generator for musicians and music labels, inspired by Faircamp",
+  "main": "dist/index.js",
+  "type": "module",
+  "bin": {
+    "tunecamp": "./dist/cli.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "start": "node dist/cli.js",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "music",
+    "static-site-generator",
+    "bandcamp",
+    "artist",
+    "album",
+    "audio"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "commander": "^11.1.0",
+    "fs-extra": "^11.2.0",
+    "glob": "^10.3.10",
+    "gun": "^0.2020.1241",
+    "handlebars": "^4.7.8",
+    "music-metadata": "^8.1.4",
+    "vercel": "^50.3.2",
+    "yaml": "^2.3.4"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "^20.10.5",
+    "typescript": "^5.3.3"
+  }
+}

package/public/assets/community-registry.js

@@ -0,0 +1,291 @@
+/**
+ * Tunecamp Community Registry
+ * Auto-registers Tunecamp sites to a global public GunDB registry
+ * 
+ * When a visitor loads any Tunecamp site, it automatically registers
+ * the site in a decentralized community directory.
+ */
+
+(function() {
+  'use strict';
+
+  // Public GunDB peers for the community registry
+  const REGISTRY_PEERS = [
+    'https://gun.defucc.me/gun',
+    'https://gun.o8.is/gun',
+    'https://shogun-relay.scobrudot.dev/gun',
+    'https://relay.peer.ooo/gun',
+  ];
+
+  const REGISTRY_ROOT = 'shogun';
+  const REGISTRY_NAMESPACE = 'tunecamp-community';
+  const REGISTRY_VERSION = '1.0';
+
+  /**
+   * TunecampCommunityRegistry
+   * Handles auto-registration and discovery of Tunecamp sites
+   */
+  class TunecampCommunityRegistry {
+    constructor() {
+      this.gun = null;
+      this.initialized = false;
+      this.siteData = null;
+    }
+
+    /**
+     * Initialize GunDB connection
+     */
+    async init() {
+      if (typeof Gun === 'undefined') {
+        console.warn('GunDB not loaded. Community registry disabled.');
+        return false;
+      }
+
+      this.gun = Gun({
+        peers: REGISTRY_PEERS,
+        localStorage: true,
+      });
+
+      this.initialized = true;
+      console.log('🌐 Tunecamp Community Registry initialized');
+      return true;
+    }
+
+    /**
+     * Generate a unique site ID from title + artist (content-based, not URL-based)
+     * This prevents duplicates when the same site is deployed to multiple URLs (e.g., Vercel previews)
+     */
+    generateSiteId(siteInfo) {
+      // Use title + artist as the unique identifier
+      // This way the same site deployed to different URLs won't create duplicates
+      const identifier = `${(siteInfo.title || 'untitled').toLowerCase().trim()}::${(siteInfo.artistName || 'unknown').toLowerCase().trim()}`;
+      
+      // Create a simple hash
+      let hash = 0;
+      for (let i = 0; i < identifier.length; i++) {
+        const char = identifier.charCodeAt(i);
+        hash = ((hash << 5) - hash) + char;
+        hash = hash & hash;
+      }
+      return Math.abs(hash).toString(36);
+    }
+
+    /**
+     * Register current site in the community registry
+     * @param {Object} siteInfo - Site information
+     * @param {string} siteInfo.url - Site URL
+     * @param {string} siteInfo.title - Catalog/Artist title
+     * @param {string} siteInfo.description - Site description
+     * @param {string} siteInfo.artistName - Artist name (optional)
+     * @param {string} siteInfo.coverImage - Cover image URL (optional)
+     */
+    async registerSite(siteInfo) {
+      if (!this.initialized || !this.gun) {
+        console.warn('Registry not initialized');
+        return false;
+      }
+
+      const siteId = this.generateSiteId(siteInfo);
+      const now = Date.now();
+
+      // Check if already registered recently (within 24h)
+      const lastRegistration = localStorage.getItem('tunecamp_registered');
+      if (lastRegistration) {
+        const lastTime = parseInt(lastRegistration, 10);
+        if (now - lastTime < 24 * 60 * 60 * 1000) {
+          // Already registered recently, just update lastSeen
+          this.gun
+            .get(REGISTRY_ROOT)
+            .get(REGISTRY_NAMESPACE)
+            .get('sites')
+            .get(siteId)
+            .get('lastSeen')
+            .put(now);
+          return true;
+        }
+      }
+
+      const siteRecord = {
+        id: siteId,
+        url: siteInfo.url,
+        title: siteInfo.title || 'Untitled',
+        description: siteInfo.description || '',
+        artistName: siteInfo.artistName || '',
+        coverImage: siteInfo.coverImage || '',
+        registeredAt: now,
+        lastSeen: now,
+        version: REGISTRY_VERSION,
+      };
+
+      return new Promise((resolve) => {
+        this.gun
+          .get(REGISTRY_ROOT)
+          .get(REGISTRY_NAMESPACE)
+          .get('sites')
+          .get(siteId)
+          .put(siteRecord, (ack) => {
+            if (ack.err) {
+              console.warn('Failed to register site:', ack.err);
+              resolve(false);
+            } else {
+              localStorage.setItem('tunecamp_registered', now.toString());
+              console.log('✅ Site registered in Tunecamp Community');
+              resolve(true);
+            }
+          });
+
+        // Timeout fallback
+        setTimeout(() => resolve(true), 3000);
+      });
+    }
+
+    /**
+     * Get all registered sites
+     * @param {function} callback - Called with array of sites
+     */
+    async getAllSites(callback) {
+      if (!this.initialized || !this.gun) {
+        callback([]);
+        return;
+      }
+
+      const sites = [];
+      const seenIds = new Set();
+
+      this.gun
+        .get(REGISTRY_ROOT)
+        .get(REGISTRY_NAMESPACE)
+        .get('sites')
+        .map()
+        .once((data, key) => {
+          if (data && data.url && !seenIds.has(key)) {
+            seenIds.add(key);
+            sites.push({
+              id: key,
+              url: data.url,
+              title: data.title || 'Untitled',
+              description: data.description || '',
+              artistName: data.artistName || '',
+              coverImage: data.coverImage || '',
+              registeredAt: data.registeredAt,
+              lastSeen: data.lastSeen,
+            });
+          }
+        });
+
+      // Give time to collect all sites
+      setTimeout(() => {
+        // Sort by lastSeen (most recent first)
+        sites.sort((a, b) => (b.lastSeen || 0) - (a.lastSeen || 0));
+        callback(sites);
+      }, 2000);
+    }
+
+    /**
+     * Subscribe to new sites (real-time)
+     * @param {function} callback - Called when a new site is added
+     */
+    subscribeToSites(callback) {
+      if (!this.initialized || !this.gun) {
+        return () => {};
+      }
+
+      const ref = this.gun
+        .get(REGISTRY_ROOT)
+        .get(REGISTRY_NAMESPACE)
+        .get('sites')
+        .map()
+        .on((data, key) => {
+          if (data && data.url) {
+            callback({
+              id: key,
+              url: data.url,
+              title: data.title || 'Untitled',
+              description: data.description || '',
+              artistName: data.artistName || '',
+              coverImage: data.coverImage || '',
+              registeredAt: data.registeredAt,
+              lastSeen: data.lastSeen,
+            });
+          }
+        });
+
+      return () => ref.off();
+    }
+
+    /**
+     * Format timestamp for display
+     */
+    formatDate(timestamp) {
+      if (!timestamp) return 'Unknown';
+      const date = new Date(timestamp);
+      return date.toLocaleDateString('en-US', {
+        year: 'numeric',
+        month: 'short',
+        day: 'numeric',
+      });
+    }
+
+    /**
+     * Get site count
+     */
+    async getSiteCount() {
+      return new Promise((resolve) => {
+        let count = 0;
+        
+        this.gun
+          .get(REGISTRY_ROOT)
+          .get(REGISTRY_NAMESPACE)
+          .get('sites')
+          .map()
+          .once((data) => {
+            if (data && data.url) count++;
+          });
+
+        setTimeout(() => resolve(count), 2000);
+      });
+    }
+  }
+
+  // Expose globally
+  window.TunecampCommunityRegistry = TunecampCommunityRegistry;
+
+  // Auto-register on page load if site data is available
+  document.addEventListener('DOMContentLoaded', async function() {
+    // Check if this is a Tunecamp site (has site metadata)
+    const siteTitle = document.querySelector('meta[name="tunecamp-title"]')?.content ||
+                      document.querySelector('.site-title a')?.textContent ||
+                      document.title;
+    
+    const siteDescription = document.querySelector('meta[name="description"]')?.content || '';
+    const artistName = document.querySelector('meta[name="tunecamp-artist"]')?.content ||
+                       document.querySelector('.release-artist')?.textContent?.replace('by ', '') || '';
+    
+    // Get cover image if available
+    const coverImage = document.querySelector('meta[property="og:image"]')?.content ||
+                       document.querySelector('.release-cover-large img')?.src ||
+                       document.querySelector('.header-image')?.src || '';
+
+    // Only register if we have a valid URL and it looks like a Tunecamp site
+    const isTunecampSite = document.querySelector('.site-footer a[href*="tunecamp"]') ||
+                          document.querySelector('meta[name="generator"][content*="Tunecamp"]');
+    
+    if (isTunecampSite || window.TUNECAMP_SITE) {
+      const registry = new TunecampCommunityRegistry();
+      const initialized = await registry.init();
+      
+      if (initialized) {
+        await registry.registerSite({
+          url: window.location.origin + window.location.pathname.replace(/\/[^\/]*$/, '/'),
+          title: siteTitle,
+          description: siteDescription,
+          artistName: artistName,
+          coverImage: coverImage,
+        });
+      }
+      
+      // Make registry available globally
+      window.tunecampRegistry = registry;
+    }
+  });
+})();

package/public/assets/download-stats.js

@@ -0,0 +1,263 @@
+/**
+ * Tunecamp Download Stats - GunDB Client
+ * Decentralized download counter using GunDB public peers
+ * 
+ * Uses a public GunDB space to track and display download counts.
+ * No authentication required - anyone can read/increment counts.
+ */
+
+(function() {
+  'use strict';
+
+  // Default public GunDB peers
+  const DEFAULT_PEERS = [
+    'https://gun.defucc.me/gun',
+    'https://gun.o8.is/gun',
+    'https://shogun-relay.scobrudot.dev/gun',
+    'https://relay.peer.ooo/gun',
+  ];
+
+  /**
+   * TunecampDownloadStats class
+   * Tracks download counts via GunDB
+   */
+  class TunecampDownloadStats {
+    /**
+     * Initialize the download stats system
+     * @param {Object} options - Configuration options
+     * @param {Array} options.peers - GunDB peer URLs (default: public peers)
+     * @param {string} options.namespace - GunDB namespace (default: 'tunecamp-stats')
+     */
+    constructor(options = {}) {
+      this.peers = options.peers || DEFAULT_PEERS;
+      this.root = options.root || 'shogun';
+      this.namespace = options.namespace || 'tunecamp-stats';
+      this.gun = null;
+      this.initialized = false;
+      
+      // Initialize GunDB when script loads
+      this.init();
+    }
+
+    /**
+     * Initialize GunDB connection
+     */
+    async init() {
+      // Check if Gun is available
+      if (typeof Gun === 'undefined') {
+        console.warn('GunDB not loaded. Download stats disabled.');
+        return;
+      }
+
+      // Initialize Gun with peers
+      this.gun = Gun({
+        peers: this.peers,
+        localStorage: true,
+      });
+
+      this.initialized = true;
+      console.log('📊 Tunecamp Download Stats initialized');
+    }
+
+    /**
+     * Wait for Gun to be ready
+     */
+    async waitForInit() {
+      if (this.initialized) return;
+      
+      return new Promise((resolve, reject) => {
+        let attempts = 0;
+        const maxAttempts = 50; // 5 seconds max
+        
+        const check = () => {
+          if (this.initialized) {
+            resolve();
+          } else if (attempts >= maxAttempts) {
+            reject(new Error('GunDB initialization timeout'));
+          } else {
+            attempts++;
+            setTimeout(check, 100);
+          }
+        };
+        check();
+      });
+    }
+
+    /**
+     * Get download count for a release
+     * @param {string} releaseSlug - The release identifier
+     * @returns {Promise<number>} Download count
+     */
+    async getDownloadCount(releaseSlug) {
+      try {
+        await this.waitForInit();
+      } catch (e) {
+        return 0;
+      }
+
+      if (!this.gun) return 0;
+
+      return new Promise((resolve) => {
+        this.gun
+          .get(this.root).get(this.namespace)
+          .get('releases')
+          .get(releaseSlug)
+          .get('downloads')
+          .once((data) => {
+            resolve(data ? parseInt(data, 10) || 0 : 0);
+          });
+
+        // Timeout fallback
+        setTimeout(() => resolve(0), 3000);
+      });
+    }
+
+    /**
+     * Get download count for a specific track
+     * @param {string} releaseSlug - The release identifier
+     * @param {string} trackId - The track identifier (filename or index)
+     * @returns {Promise<number>} Download count
+     */
+    async getTrackDownloadCount(releaseSlug, trackId) {
+      try {
+        await this.waitForInit();
+      } catch (e) {
+        return 0;
+      }
+
+      if (!this.gun) return 0;
+
+      return new Promise((resolve) => {
+        this.gun
+          .get(this.root).get(this.namespace)
+          .get('releases')
+          .get(releaseSlug)
+          .get('tracks')
+          .get(trackId)
+          .get('downloads')
+          .once((data) => {
+            resolve(data ? parseInt(data, 10) || 0 : 0);
+          });
+
+        // Timeout fallback
+        setTimeout(() => resolve(0), 3000);
+      });
+    }
+
+    /**
+     * Increment download count for a release
+     * @param {string} releaseSlug - The release identifier
+     * @returns {Promise<number>} New download count
+     */
+    async incrementDownloadCount(releaseSlug) {
+      try {
+        await this.waitForInit();
+      } catch (e) {
+        return 0;
+      }
+
+      if (!this.gun) return 0;
+
+      const currentCount = await this.getDownloadCount(releaseSlug);
+      const newCount = currentCount + 1;
+
+      return new Promise((resolve) => {
+        this.gun
+          .get(this.root).get(this.namespace)
+          .get('releases')
+          .get(releaseSlug)
+          .get('downloads')
+          .put(newCount, (ack) => {
+            if (ack.err) {
+              console.error('Error incrementing download count:', ack.err);
+              resolve(currentCount);
+            } else {
+              resolve(newCount);
+            }
+          });
+
+        // Timeout fallback
+        setTimeout(() => resolve(newCount), 2000);
+      });
+    }
+
+    /**
+     * Increment download count for a specific track
+     * @param {string} releaseSlug - The release identifier
+     * @param {string} trackId - The track identifier
+     * @returns {Promise<number>} New download count
+     */
+    async incrementTrackDownloadCount(releaseSlug, trackId) {
+      try {
+        await this.waitForInit();
+      } catch (e) {
+        return 0;
+      }
+
+      if (!this.gun) return 0;
+
+      const currentCount = await this.getTrackDownloadCount(releaseSlug, trackId);
+      const newCount = currentCount + 1;
+
+      return new Promise((resolve) => {
+        this.gun
+          .get(this.root).get(this.namespace)
+          .get('releases')
+          .get(releaseSlug)
+          .get('tracks')
+          .get(trackId)
+          .get('downloads')
+          .put(newCount, (ack) => {
+            if (ack.err) {
+              console.error('Error incrementing track download count:', ack.err);
+              resolve(currentCount);
+            } else {
+              resolve(newCount);
+            }
+          });
+
+        // Timeout fallback
+        setTimeout(() => resolve(newCount), 2000);
+      });
+    }
+
+    /**
+     * Subscribe to download count changes (real-time updates)
+     * @param {string} releaseSlug - The release identifier
+     * @param {function} callback - Called with new count on each update
+     */
+    subscribeToDownloadCount(releaseSlug, callback) {
+      if (!this.gun) {
+        callback(0);
+        return () => {};
+      }
+
+      const ref = this.gun
+        .get(this.root).get(this.namespace)
+        .get('releases')
+        .get(releaseSlug)
+        .get('downloads');
+
+      ref.on((data) => {
+        callback(data ? parseInt(data, 10) || 0 : 0);
+      });
+
+      // Return unsubscribe function
+      return () => ref.off();
+    }
+
+    /**
+     * Format download count for display
+     * @param {number} count - Download count
+     * @returns {string} Formatted string (e.g., "1.2K", "3.5M")
+     */
+    formatCount(count) {
+      if (count < 1000) return count.toString();
+      if (count < 1000000) return (count / 1000).toFixed(1).replace(/\.0$/, '') + 'K';
+      return (count / 1000000).toFixed(1).replace(/\.0$/, '') + 'M';
+    }
+  }
+
+  // Expose globally
+  window.TunecampDownloadStats = TunecampDownloadStats;
+})();