lucille-node 0.0.1

package/src/persistence/client.js

@@ -0,0 +1,83 @@
+import { promises as fs } from 'fs';
+import path from 'path';
+
+const keyDepth = 2;
+const delimiter = '_';
+const basePath = 'data/lucille';
+
+const filePathForKey = async (key) => {
+  let mutatingKey = key.replace(':', delimiter).trim();
+  const filePathParts = [];
+  for (let i = 0; i < keyDepth; i++) {
+    filePathParts.push(mutatingKey.slice(-3));
+    mutatingKey = mutatingKey.slice(0, -3);
+  }
+  filePathParts.push(mutatingKey);
+  filePathParts.push(basePath);
+
+  const filePath = filePathParts.reverse().join('/');
+  return filePath;
+};
+
+const set = async (key, value) => {
+  const filePath = await filePathForKey(key);
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+  await fs.writeFile(filePath, value);
+  return true;
+};
+
+const get = async (key) => {
+  const filePath = await filePathForKey(key);
+  try {
+    return await fs.readFile(filePath, 'utf8');
+  } catch (err) {
+    return null;
+  }
+};
+
+const getAll = async (pattern) => {
+  try {
+    const entries = await fs.readdir(basePath, { recursive: true, withFileTypes: true });
+
+    const filteredEntries = entries.filter(entry => {
+      const isFile = entry.isFile();
+      const relativePath = entry.path
+        ? path.relative(basePath, path.join(entry.path, entry.name))
+        : entry.name;
+      return isFile && relativePath.indexOf(pattern) > -1;
+    });
+
+    const files = filteredEntries.map(async entry => {
+      const fullPath = path.join(entry.path || basePath, entry.name);
+      const relativePath = entry.path
+        ? path.relative(basePath, path.join(entry.path, entry.name))
+        : entry.name;
+      return {
+        filename: relativePath,
+        content: await fs.readFile(fullPath, 'utf8')
+      };
+    });
+
+    return await Promise.all(files);
+  } catch (err) {
+    return [];
+  }
+};
+
+const del = async (key) => {
+  const filePath = await filePathForKey(key);
+  await fs.unlink(filePath);
+  return true;
+};
+
+const createClient = () => {
+  return {
+    on: () => createClient,
+  };
+};
+
+createClient.connect = () => {
+  return { set, get, getAll, del };
+};
+
+export { createClient };

package/src/persistence/db.js

@@ -0,0 +1,105 @@
+import crypto from 'crypto';
+import { createClient } from './client.js';
+import sessionless from 'sessionless-node';
+
+const client = await createClient()
+  .on('error', err => console.log('Client Error', err))
+  .connect();
+
+const db = {
+  getUserByUUID: async (uuid) => {
+    const user = await client.get(`user:${uuid}`);
+    if (!user) throw new Error('not found');
+    return JSON.parse(user);
+  },
+
+  getUserByPublicKey: async (pubKey) => {
+    const uuid = await client.get(`pubKey:${pubKey}`);
+    if (!uuid) throw new Error('not found');
+    const user = await client.get(`user:${uuid}`);
+    if (!user) throw new Error('not found');
+    return JSON.parse(user);
+  },
+
+  putUser: async (user) => {
+    const uuid = sessionless.generateUUID();
+    user.uuid = uuid;
+    await client.set(`user:${uuid}`, JSON.stringify(user));
+    await client.set(`pubKey:${user.pubKey}`, uuid);
+    return user;
+  },
+
+  saveUser: async (user) => {
+    await client.set(`user:${user.uuid}`, JSON.stringify(user));
+    return true;
+  },
+
+  deleteUser: async (user) => {
+    await client.del(`pubKey:${user.pubKey}`);
+    await client.del(`user:${user.uuid}`);
+    return true;
+  },
+
+  saveKeys: async (keys) => {
+    await client.set('keys', JSON.stringify(keys));
+  },
+
+  getKeys: async () => {
+    const keyString = await client.get('keys');
+    return JSON.parse(keyString);
+  },
+
+  putVideo: async (user, video) => {
+    const uuid = user.uuid;
+    video.uuid = uuid;
+    video.videoId = crypto.createHash('sha256').update(uuid + video.title).digest('hex');
+    video.createdAt = video.createdAt || new Date().toISOString();
+    await client.set(`${uuid}:video:${video.title}`, JSON.stringify(video));
+
+    // Reverse index for O(1) watch lookup
+    await client.set(`videoId:${video.videoId}`, JSON.stringify({ uuid, title: video.title }));
+
+    const videosJSON = (await client.get(`videos:${uuid}`)) || '{}';
+    const videos = JSON.parse(videosJSON);
+    videos[video.title] = video;
+    await client.set(`videos:${uuid}`, JSON.stringify(videos));
+
+    return video;
+  },
+
+  getVideo: async (uuid, title) => {
+    const videoJSON = await client.get(`${uuid}:video:${title}`);
+    if (!videoJSON) throw new Error('not found');
+    return JSON.parse(videoJSON);
+  },
+
+  saveVideo: async (video) => {
+    await client.set(`${video.uuid}:video:${video.title}`, JSON.stringify(video));
+    if (video.videoId) {
+      await client.set(`videoId:${video.videoId}`, JSON.stringify({ uuid: video.uuid, title: video.title }));
+    }
+
+    const videosJSON = (await client.get(`videos:${video.uuid}`)) || '{}';
+    const videos = JSON.parse(videosJSON);
+    videos[video.title] = video;
+    await client.set(`videos:${video.uuid}`, JSON.stringify(videos));
+
+    return true;
+  },
+
+  getVideos: async (uuid) => {
+    const videosJSON = (await client.get(`videos:${uuid}`)) || '{}';
+    return JSON.parse(videosJSON);
+  },
+
+  getVideoByVideoId: async (videoId) => {
+    const refJSON = await client.get(`videoId:${videoId}`);
+    if (!refJSON) throw new Error('not found');
+    const { uuid, title } = JSON.parse(refJSON);
+    const videoJSON = await client.get(`${uuid}:video:${title}`);
+    if (!videoJSON) throw new Error('not found');
+    return JSON.parse(videoJSON);
+  }
+};
+
+export default db;

package/src/seeder.js

@@ -0,0 +1,112 @@
+import WebTorrent from 'webtorrent';
+import https from 'https';
+import http from 'http';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { presignedGet, listVideos } from './spaces.js';
+import { TRACKER_PORT } from './tracker.js';
+
+const wtClient = new WebTorrent();
+
+// Map of Spaces key → torrent instance
+const torrents = new Map();
+
+// Full announce list: own tracker + all federation peer trackers.
+// Populated on startup by lucille.js after fetching peers; falls back to own tracker only.
+let _trackerList = null;
+
+const getOwnTrackerUrl = () =>
+  process.env.TRACKER_URL || `ws://localhost:${TRACKER_PORT}`;
+
+/**
+ * Called from lucille.js after fetching federation peer tracker URLs.
+ * Merges own tracker with peer trackers, deduplicates.
+ */
+const updateTrackerList = (peerTrackerUrls = []) => {
+  const all = [getOwnTrackerUrl(), ...peerTrackerUrls].filter(Boolean);
+  _trackerList = [...new Set(all)];
+  console.log(`[lucille] Tracker announce list (${_trackerList.length}): ${_trackerList.join(', ')}`);
+};
+
+const getAnnounceList = () => {
+  return _trackerList || [getOwnTrackerUrl()];
+};
+
+const downloadToTemp = (url, filename) => {
+  return new Promise((resolve, reject) => {
+    const dest = path.join(os.tmpdir(), filename);
+    if (fs.existsSync(dest)) return resolve(dest);
+
+    const file = fs.createWriteStream(dest);
+    const getter = url.startsWith('https') ? https : http;
+
+    getter.get(url, res => {
+      res.pipe(file);
+      file.on('finish', () => file.close(() => resolve(dest)));
+    }).on('error', err => {
+      fs.unlink(dest, () => {});
+      reject(err);
+    });
+  });
+};
+
+const seedVideo = async (key) => {
+  if (torrents.has(key)) return torrents.get(key);
+
+  console.log(`[lucille] Seeding: ${key}`);
+  const url = await presignedGet(key);
+  const filename = path.basename(key);
+  const localPath = await downloadToTemp(url, filename);
+
+  return new Promise((resolve, reject) => {
+    wtClient.seed(localPath, {
+      announce: getAnnounceList()
+    }, torrent => {
+      torrents.set(key, torrent);
+      console.log(`[lucille] Seeding ${filename} — ${torrent.magnetURI.slice(0, 60)}…`);
+      resolve(torrent);
+    });
+  });
+};
+
+const seedAll = async () => {
+  const videos = await listVideos();
+  for (const video of videos) {
+    await seedVideo(video.key).catch(err =>
+      console.error(`[lucille] Failed to seed ${video.key}:`, err.message)
+    );
+  }
+};
+
+const getMagnet = async (key) => {
+  const torrent = await seedVideo(key);
+  return {
+    magnetURI: torrent.magnetURI,
+    infoHash: torrent.infoHash,
+    name: torrent.name
+  };
+};
+
+const getStatus = () => {
+  const active = [];
+  for (const [key, torrent] of torrents.entries()) {
+    active.push({
+      key,
+      infoHash: torrent.infoHash,
+      peers: torrent.numPeers,
+      uploadSpeed: torrent.uploadSpeed,
+      downloaded: torrent.downloaded
+    });
+  }
+  return {
+    trackers: getAnnounceList(),
+    torrents: active,
+    totalPeers: wtClient.torrents.reduce((n, t) => n + t.numPeers, 0)
+  };
+};
+
+const destroySeeder = () =>
+  new Promise(resolve => wtClient.destroy(() => resolve()));
+
+export { seedVideo, seedAll, getMagnet, getStatus, destroySeeder, updateTrackerList };

package/src/spaces.js

@@ -0,0 +1,68 @@
+import { S3Client, PutObjectCommand, GetObjectCommand, ListObjectsV2Command } from '@aws-sdk/client-s3';
+import { getSignedUrl } from '@aws-sdk/s3-request-presigner';
+import fs from 'fs';
+
+const client = new S3Client({
+  endpoint: `https://${process.env.DO_SPACES_REGION}.digitaloceanspaces.com`,
+  region: process.env.DO_SPACES_REGION,
+  credentials: {
+    accessKeyId: process.env.DO_SPACES_KEY,
+    secretAccessKey: process.env.DO_SPACES_SECRET
+  }
+});
+
+const BUCKET = process.env.DO_SPACES_BUCKET;
+
+const uploadVideo = async (localPath, key) => {
+  const stream = fs.createReadStream(localPath);
+  const stat = fs.statSync(localPath);
+
+  await client.send(new PutObjectCommand({
+    Bucket: BUCKET,
+    Key: key,
+    Body: stream,
+    ContentLength: stat.size,
+    ContentType: 'video/mp4',
+    ACL: 'private'
+  }));
+
+  console.log(`Uploaded ${key} (${(stat.size / 1e9).toFixed(2)} GB)`);
+  return key;
+};
+
+const uploadVideoBuffer = async (buffer, key, contentType = 'video/mp4') => {
+  await client.send(new PutObjectCommand({
+    Bucket: BUCKET,
+    Key: key,
+    Body: buffer,
+    ContentLength: buffer.length,
+    ContentType: contentType,
+    ACL: 'private'
+  }));
+
+  console.log(`Uploaded ${key} (${(buffer.length / 1e6).toFixed(2)} MB)`);
+  return key;
+};
+
+const presignedGet = async (key, expiresIn = 3600) => {
+  const command = new GetObjectCommand({ Bucket: BUCKET, Key: key });
+  return getSignedUrl(client, command, { expiresIn });
+};
+
+const listVideos = async (prefix = 'videos/') => {
+  const response = await client.send(new ListObjectsV2Command({
+    Bucket: BUCKET,
+    Prefix: prefix
+  }));
+  return (response.Contents || []).map(obj => ({
+    key: obj.Key,
+    size: obj.Size,
+    lastModified: obj.LastModified
+  }));
+};
+
+const cdnUrl = (key) => {
+  return `${process.env.DO_SPACES_CDN_ENDPOINT}/${key}`;
+};
+
+export { uploadVideo, uploadVideoBuffer, presignedGet, listVideos, cdnUrl };

package/src/tracker.js

@@ -0,0 +1,49 @@
+import { Server } from 'bittorrent-tracker';
+
+const TRACKER_PORT = parseInt(process.env.TRACKER_PORT) || 8000;
+
+let trackerServer = null;
+
+const startTracker = () => {
+  return new Promise((resolve, reject) => {
+    trackerServer = new Server({
+      udp: false,
+      http: true,
+      ws: true,
+      stats: true
+    });
+
+    trackerServer.on('error', err => console.error('Tracker error:', err.message));
+    trackerServer.on('warning', msg => console.warn('Tracker warning:', msg));
+
+    trackerServer.on('listening', () => {
+      console.log(`Tracker WS  listening on ws://0.0.0.0:${TRACKER_PORT}`);
+      console.log(`Tracker HTTP listening on http://0.0.0.0:${TRACKER_PORT}`);
+      resolve(trackerServer);
+    });
+
+    trackerServer.on('start', (addr, params) => {
+      const hash = params.info_hash ? params.info_hash.toString('hex').slice(0, 8) : 'unknown';
+      console.log(`Peer joined  infoHash=${hash}`);
+    });
+
+    trackerServer.on('stop', (addr, params) => {
+      const hash = params.info_hash ? params.info_hash.toString('hex').slice(0, 8) : 'unknown';
+      console.log(`Peer left    infoHash=${hash}`);
+    });
+
+    trackerServer.listen(TRACKER_PORT, () => resolve(trackerServer));
+  });
+};
+
+const stopTracker = () => {
+  return new Promise((resolve) => {
+    if (trackerServer) {
+      trackerServer.close(() => resolve());
+    } else {
+      resolve();
+    }
+  });
+};
+
+export { startTracker, stopTracker, TRACKER_PORT };

package/templates/player.html

@@ -0,0 +1,236 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Lucille</title>
+  <style>
+    *, *::before, *::after { box-sizing: border-box; margin: 0; padding: 0; }
+
+    body {
+      background: #000;
+      color: #fff;
+      font-family: system-ui, sans-serif;
+      height: 100dvh;
+      display: flex;
+      flex-direction: column;
+      overflow: hidden;
+    }
+
+    #video-wrap {
+      flex: 1;
+      position: relative;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      background: #000;
+      min-height: 0;
+    }
+
+    video {
+      max-width: 100%;
+      max-height: 100%;
+      width: 100%;
+      display: block;
+    }
+
+    /* Overlay shown while loading */
+    #overlay {
+      position: absolute;
+      inset: 0;
+      display: flex;
+      flex-direction: column;
+      align-items: center;
+      justify-content: center;
+      gap: 16px;
+      background: rgba(0,0,0,0.75);
+      transition: opacity 0.4s;
+    }
+
+    #overlay.hidden { opacity: 0; pointer-events: none; }
+
+    .spinner {
+      width: 48px;
+      height: 48px;
+      border: 4px solid rgba(255,255,255,0.2);
+      border-top-color: #fff;
+      border-radius: 50%;
+      animation: spin 0.8s linear infinite;
+    }
+    @keyframes spin { to { transform: rotate(360deg); } }
+
+    #overlay-msg {
+      font-size: 0.9rem;
+      color: rgba(255,255,255,0.7);
+      text-align: center;
+      padding: 0 24px;
+    }
+
+    #progress-bar-wrap {
+      width: 200px;
+      height: 4px;
+      background: rgba(255,255,255,0.15);
+      border-radius: 2px;
+      overflow: hidden;
+      display: none;
+    }
+    #progress-bar {
+      height: 100%;
+      width: 0%;
+      background: #fff;
+      border-radius: 2px;
+      transition: width 0.3s;
+    }
+
+    /* Bottom info bar */
+    #info-bar {
+      flex-shrink: 0;
+      display: flex;
+      align-items: center;
+      justify-content: space-between;
+      padding: 8px 16px;
+      background: #111;
+      font-size: 0.8rem;
+      color: rgba(255,255,255,0.5);
+      gap: 12px;
+      min-height: 36px;
+    }
+
+    #video-title {
+      font-weight: 600;
+      color: #fff;
+      white-space: nowrap;
+      overflow: hidden;
+      text-overflow: ellipsis;
+      flex: 1;
+    }
+
+    #peer-count { white-space: nowrap; flex-shrink: 0; }
+    #peer-count.active { color: #4ade80; }
+
+    /* Error state */
+    #error-msg {
+      display: none;
+      position: absolute;
+      inset: 0;
+      align-items: center;
+      justify-content: center;
+      flex-direction: column;
+      gap: 12px;
+      background: #000;
+      color: rgba(255,255,255,0.6);
+      font-size: 0.9rem;
+      text-align: center;
+      padding: 24px;
+    }
+    #error-msg.show { display: flex; }
+    #error-msg strong { font-size: 1.1rem; color: #fff; }
+  </style>
+</head>
+<body>
+
+<div id="video-wrap">
+  <video id="video" controls playsinline></video>
+
+  <div id="overlay">
+    <div class="spinner"></div>
+    <div id="overlay-msg">Fetching video info…</div>
+    <div id="progress-bar-wrap"><div id="progress-bar"></div></div>
+  </div>
+
+  <div id="error-msg">
+    <strong>Unable to load video</strong>
+    <span id="error-detail"></span>
+  </div>
+</div>
+
+<div id="info-bar">
+  <span id="video-title">Lucille</span>
+  <span id="peer-count">⬤ connecting…</span>
+</div>
+
+<script src="https://cdn.jsdelivr.net/npm/webtorrent@latest/webtorrent.min.js"></script>
+<script>
+(async () => {
+  const videoEl      = document.getElementById('video');
+  const overlay      = document.getElementById('overlay');
+  const overlayMsg   = document.getElementById('overlay-msg');
+  const progressWrap = document.getElementById('progress-bar-wrap');
+  const progressBar  = document.getElementById('progress-bar');
+  const titleEl      = document.getElementById('video-title');
+  const peerEl       = document.getElementById('peer-count');
+  const errorEl      = document.getElementById('error-msg');
+  const errorDetail  = document.getElementById('error-detail');
+
+  function showError(msg) {
+    overlay.classList.add('hidden');
+    errorEl.classList.add('show');
+    errorDetail.textContent = msg;
+  }
+
+  // --- 1. Extract videoId from URL path ---
+  const videoId = window.location.pathname.split('/').filter(Boolean).pop();
+  if (!videoId) { showError('No video ID in URL.'); return; }
+
+  // --- 2. Call the streaming API ---
+  let watchInfo;
+  try {
+    const res = await fetch(`/video/${videoId}/watch`);
+    if (!res.ok) { showError(`Video not found (${res.status}).`); return; }
+    watchInfo = await res.json();
+  } catch (err) {
+    showError('Could not reach Lucille API.');
+    return;
+  }
+
+  const { magnetURI, title, trackerUrl } = watchInfo;
+  if (title) {
+    titleEl.textContent = title;
+    document.title = title + ' — Lucille';
+  }
+
+  // --- 3. Stream via WebTorrent ---
+  overlayMsg.textContent = 'Connecting to peers…';
+
+  const client = new WebTorrent();
+
+  client.on('error', err => showError(err.message));
+
+  client.add(magnetURI, { announce: trackerUrl ? [trackerUrl] : [] }, torrent => {
+    // Pick the largest file (the video)
+    const file = torrent.files.reduce((a, b) => a.length > b.length ? a : b);
+
+    overlayMsg.textContent = 'Buffering…';
+    progressWrap.style.display = 'block';
+
+    file.renderTo(videoEl, err => {
+      if (err) { showError(err.message); return; }
+      overlay.classList.add('hidden');
+    });
+
+    // Progress while buffering
+    const progressInterval = setInterval(() => {
+      const pct = (torrent.progress * 100).toFixed(1);
+      progressBar.style.width = pct + '%';
+      if (torrent.progress > 0.01) {
+        overlayMsg.textContent = `Buffering… ${pct}%`;
+      }
+      if (torrent.progress >= 1) clearInterval(progressInterval);
+    }, 500);
+
+    // Peer count in info bar
+    setInterval(() => {
+      const n = torrent.numPeers;
+      peerEl.textContent = `⬤ ${n} peer${n !== 1 ? 's' : ''}`;
+      peerEl.className = n > 0 ? 'active' : '';
+    }, 2000);
+
+    // Hide overlay once enough is downloaded to play
+    videoEl.addEventListener('canplay', () => {
+      overlay.classList.add('hidden');
+    }, { once: true });
+  });
+})();
+</script>
+</body>
+</html>