ani-auto 1.4.4 → 2.0.0

package/src/api/update.js

@@ -0,0 +1,96 @@
+'use strict';
+
+const { Router } = require('express');
+const fetch = require('node-fetch');
+const { exec } = require('child_process');
+const { version } = require('../../package.json');
+
+const router = Router();
+
+router.get('/check', async (req, res) => {
+  try {
+    const response = await fetch('https://registry.npmjs.org/ani-auto/latest', {
+      timeout: 10000,
+    });
+    const data = await response.json();
+    const latest = data.version;
+    res.json({
+      current: version,
+      latest,
+      updateAvailable: latest !== version,
+    });
+  } catch (e) {
+    res.json({
+      current: version,
+      latest: version,
+      updateAvailable: false,
+      error: e.message,
+    });
+  }
+});
+
+router.post('/install', async (req, res) => {
+  const broadcast = req.app.locals.broadcast;
+  if (!broadcast) {
+    return res.status(500).json({ error: 'WebSocket not available' });
+  }
+
+  res.json({ ok: true, message: 'Update started' });
+
+  broadcast('update:progress', { percent: 5, message: 'Checking latest version...' });
+
+  try {
+    const response = await fetch('https://registry.npmjs.org/ani-auto/latest', {
+      timeout: 10000,
+    });
+    const data = await response.json();
+    const latest = data.version;
+
+    if (latest === version) {
+      broadcast('update:done', {
+        version,
+        message: `Already on v${version}`,
+      });
+      return;
+    }
+
+    broadcast('update:progress', {
+      percent: 15,
+      message: `Updating v${version} → v${latest}...`,
+    });
+
+    const child = exec(
+      `npm install -g ani-auto@${latest}`,
+      { timeout: 120000 },
+      (error) => {
+        if (error) {
+          broadcast('update:error', {
+            error: `Install failed: ${error.message}`,
+          });
+          return;
+        }
+        broadcast('update:progress', { percent: 95, message: 'Finalizing...' });
+        setTimeout(() => {
+          broadcast('update:done', {
+            version: latest,
+            message: `Updated to v${latest}`,
+          });
+        }, 500);
+      }
+    );
+
+    child.stdout?.on('data', (chunk) => {
+      const text = chunk.toString();
+      if (text.includes('added') || text.includes('changed')) {
+        broadcast('update:progress', {
+          percent: 60,
+          message: 'Packages installed',
+        });
+      }
+    });
+  } catch (e) {
+    broadcast('update:error', { error: e.message });
+  }
+});
+
+module.exports = router;

package/src/cli.js

@@ -100,13 +100,19 @@ program
 
         if (answers.anilistToken) {
             const spinner = ora('Verifying AniList token...').start();
-            try { const viewer = await getViewer(answers.anilistToken); spinner.succeed(`Logged in as ${chalk.bold(viewer.name)}`); }
-            catch { spinner.warn('Could not verify token - saved anyway, check it manually.'); }
+            try {
+                const viewer = await getViewer(answers.anilistToken);
+                spinner.succeed(`Logged in as ${chalk.bold(viewer.name)}`);
+                answers.anilistAvatar = viewer.avatar?.medium || null;
+            } catch {
+                spinner.warn('Could not verify token - saved anyway, check it manually.');
+            }
         }
 
         updateConfig({
             anilistUsername:       answers.anilistUsername || null,
             anilistToken:          answers.anilistToken    || null,
+            anilistAvatar:         answers.anilistAvatar   || null,
             watchStatuses:         answers.watchStatuses   || current.watchStatuses,
             quality:               answers.quality,
             concurrency:           answers.concurrency,
@@ -806,6 +812,16 @@ program
         }
     });
 
+// ── web ───────────────────────────────────────────────────────────────────
+
+program
+    .command('web')
+    .description('Start the web UI server on port 2640')
+    .action(() => {
+        const { startServer } = require('./server');
+        startServer();
+    });
+
 // ── main ──────────────────────────────────────────────────────────────────
 
 program

package/src/config.js

@@ -23,18 +23,30 @@ const DEFAULTS = {
     telegramChatId:        null,
     telegramNotify:        true,
     airingBufferMinutes:   5,
-    daemonEnabled:         true,         // set to false via `ani-auto daemon disable`
+    daemonEnabled:         true,
+    autoUpdateCheck:       true,
     apiBaseUrl:            'https://aor-rex-anikuro-api.hf.space',
+    anilistClientId:       '37183',
+    anilistClientSecret:   null,
+    animepaheCfClearance:  null,
+    animepaheUserAgent:    null,
 };
 
 function ensureConfigDir() {
     if (!fs.existsSync(CONFIG_DIR)) fs.mkdirSync(CONFIG_DIR, { recursive: true });
 }
 
+const SENTINEL = '[set]';
+const MASKABLE_KEYS = new Set(['anilistToken', 'anilistClientSecret', 'animepaheCfClearance', 'animepaheUserAgent']);
+
 function loadConfig() {
     ensureConfigDir();
     if (!fs.existsSync(CONFIG_FILE)) { saveConfig(DEFAULTS); return { ...DEFAULTS }; }
-    try { return { ...DEFAULTS, ...JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8')) }; }
+    try {
+        const cfg = { ...DEFAULTS, ...JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8')) };
+        for (const k of MASKABLE_KEYS) { if (cfg[k] === SENTINEL) cfg[k] = null; }
+        return cfg;
+    }
     catch { return { ...DEFAULTS }; }
 }
 

package/src/daemon.js

@@ -22,7 +22,7 @@ async function safeRun() {
         return;
     }
 
-    // Check internet before running
+      // Check internet before running
     const online = await checkInternet();
     if (!online) {
         warn('No internet connection — waiting for network...');

package/src/db.js

@@ -117,17 +117,35 @@ function _run(sql, params = []) {
 }
 
 
-function upsertAnime({ title, siteId, anilistId, source, quality, language }) {
-    _run(`
-        INSERT INTO anime (title, site_id, anilist_id, source, quality, language)
-        VALUES (?, ?, ?, ?, ?, ?)
-        ON CONFLICT(site_id) DO UPDATE SET
-            title      = excluded.title,
-            anilist_id = COALESCE(excluded.anilist_id, anime.anilist_id),
-            quality    = COALESCE(excluded.quality, anime.quality),
-            language   = COALESCE(excluded.language, anime.language)
-    `, [title, siteId || title, anilistId || null, source || 'anilist', quality || null, language || null]);
-    return _get('SELECT * FROM anime WHERE site_id = ?', [siteId || title]);
+function upsertAnime({ title, siteId, anilistId, source, quality, language, poster_url }) {
+    const finalSiteId = siteId || title;
+    const finalAnilistId = anilistId || null;
+
+    const existing = finalAnilistId
+        ? (_get('SELECT id FROM anime WHERE anilist_id = ?', [finalAnilistId]) ||
+           _get('SELECT id FROM anime WHERE site_id = ?', [finalSiteId]))
+        : _get('SELECT id FROM anime WHERE site_id = ?', [finalSiteId]);
+
+    if (existing) {
+        _run(`
+            UPDATE anime SET
+                title      = ?,
+                site_id    = ?,
+                anilist_id = COALESCE(?, anime.anilist_id),
+                source     = ?,
+                quality    = COALESCE(?, anime.quality),
+                language   = COALESCE(?, anime.language),
+                poster_url = COALESCE(?, anime.poster_url)
+            WHERE id = ?
+        `, [title, finalSiteId, finalAnilistId, source || 'anilist', quality || null, language || null, poster_url || null, existing.id]);
+    } else {
+        _run(`
+            INSERT INTO anime (title, site_id, anilist_id, source, quality, language, poster_url)
+            VALUES (?, ?, ?, ?, ?, ?, ?)
+        `, [title, finalSiteId, finalAnilistId, source || 'anilist', quality || null, language || null, poster_url || null]);
+    }
+    return _get('SELECT * FROM anime WHERE site_id = ?', [finalSiteId]) ||
+           _get('SELECT * FROM anime WHERE anilist_id = ?', [finalAnilistId]);
 }
 
 function getAnime(siteId) {
@@ -263,9 +281,18 @@ function updateNextAiring(animeDbId, airingAt) {
     _run('UPDATE anime SET next_airing_at = ? WHERE id = ?', [airingAt, animeDbId]);
 }
 
+function execSql(sql, params = []) {
+    _run(sql, params);
+}
+
+function saveDb() {
+    _save();
+}
+
 module.exports = {
     initDb,
     getDb: getDbInstance,
+    execSql, saveDb,
     upsertAnime, getAnime, getAnimeBySiteTitle, saveConfirmedSiteMatch, getAllEnabledAnime, setAnimeEnabled, setAnimeQuality, removeAnime,
     isEpisodeDownloaded, getEpisodeRow, markEpisodeStatus, getEpisodeStats, getFailedEpisodes, getAllEpisodes, updateNextAiring,
     logRun, getRecentRuns,

package/src/engine.js

@@ -15,11 +15,14 @@ const notify                     = require('./notify');
 
 // ── Logging ────────────────────────────────────────────────────────────────
 
-function info(msg) { console.log(`${chalk.gray(ts())} ${chalk.cyan('ℹ')}  ${msg}`); }
-function ok(msg)   { console.log(`${chalk.gray(ts())} ${chalk.green('✔')}  ${msg}`); }
-function warn(msg) { console.log(`${chalk.gray(ts())} ${chalk.yellow('⚠')}  ${msg}`); }
-function err(msg)  { console.log(`${chalk.gray(ts())} ${chalk.red('✖')}  ${msg}`); }
+let currentBus = null;
+
+function info(msg) { const m = stripAnsi(msg); console.log(`${chalk.gray(ts())} ${chalk.cyan('ℹ')}  ${msg}`); if (currentBus) currentBus.emit('broadcast', 'log', { level: 'info', message: m, timestamp: ts() }); }
+function ok(msg)   { const m = stripAnsi(msg); console.log(`${chalk.gray(ts())} ${chalk.green('✔')}  ${msg}`); if (currentBus) currentBus.emit('broadcast', 'log', { level: 'ok', message: m, timestamp: ts() }); }
+function warn(msg) { const m = stripAnsi(msg); console.log(`${chalk.gray(ts())} ${chalk.yellow('⚠')}  ${msg}`); if (currentBus) currentBus.emit('broadcast', 'log', { level: 'warn', message: m, timestamp: ts() }); }
+function err(msg)  { const m = stripAnsi(msg); console.log(`${chalk.gray(ts())} ${chalk.red('✖')}  ${msg}`); if (currentBus) currentBus.emit('broadcast', 'log', { level: 'err', message: m, timestamp: ts() }); }
 function ts()      { return new Date().toISOString().replace('T', ' ').slice(0, 19); }
+function stripAnsi(s) { return s.replace(/\x1b\[[0-9;]*m/g, ''); }
 
 // ── Filename helpers ───────────────────────────────────────────────────────
 
@@ -172,7 +175,7 @@ async function promptAnimeSelection(watchList) {
 
 // ── Per-anime download ─────────────────────────────────────────────────────
 
-async function processAnime(workItem, config, multiBar, auto = false, runQuality = null, runLanguage = null, range = null) {
+async function processAnime(workItem, config, multiBar, auto = false, runQuality = null, runLanguage = null, range = null, eventBus = null) {
     // Per-anime quality: run override > DB override > workItem > global config
     const dbAnimeRow = db.getAnimeBySiteTitle(workItem.title);
     const q = runQuality || dbAnimeRow?.override_quality || workItem.quality || config.quality || '1080p';
@@ -193,7 +196,8 @@ async function processAnime(workItem, config, multiBar, auto = false, runQuality
         if (idMatch) {
             siteAnime = idMatch;
             info(`[${workItem.title}] Matched by AniList ID: ${chalk.bold(siteAnime.title)} (anilist:${siteAnime.anilistId})`);
-            db.saveConfirmedSiteMatch(workItem.title, siteAnime.session, siteAnime.title, siteAnime.poster || null);
+            const poster = workItem.posterUrl || siteAnime.poster || null;
+            db.saveConfirmedSiteMatch(workItem.title, siteAnime.session, siteAnime.title, poster);
         } else {
             warn(`[${workItem.title}] AniList ID ${workItem.anilistId} not found in search results — falling back to title match.`);
         }
@@ -328,6 +332,15 @@ async function processAnime(workItem, config, multiBar, auto = false, runQuality
 
     info(`[${workItem.title}] ${toDownload.length} unwatched episode(s) to download (Q:${q} L:${l}, skipping first ${watched}).`);
 
+    if (eventBus) {
+      eventBus.emit('broadcast', 'anime:start', {
+        animeId: dbRow?.id,
+        title: workItem.title,
+        episodeCount: toDownload.length,
+        quality: q,
+      });
+    }
+
     const posterUrl = workItem.posterUrl || null;
     await notify.notifyDownloadStart(cleanTitle, toDownload.length, q, posterUrl);
 
@@ -356,13 +369,22 @@ async function processAnime(workItem, config, multiBar, auto = false, runQuality
             while (!success && attempts < MAX_RETRIES) {
                 attempts++;
                 try {
+                    if (eventBus) {
+                      eventBus.emit('broadcast', 'episode:start', {
+                        animeId: dbRow?.id,
+                        title: cleanTitle,
+                        episode: ep.episode,
+                        quality: q,
+                      });
+                    }
+
                     const links = await scraper.getDownloadLinks(siteAnime.session, ep.session, q);
                     const link  = scraper.pickLink(links, q, l);
                     if (!link?.mp4Url) throw new Error('No suitable download link found');
 
                     const relativeEp = epRelativeMap.get(ep.episode) || ep.episode;
                     const filename   = buildFilename(displayTitle, ep.episode, season, relativeEp);
-                    await scraper.downloadEpisode(link.mp4Url, filename, outputDir, multiBar, ep.episode);
+                    await scraper.downloadEpisode(link.mp4Url, filename, outputDir, multiBar, ep.episode, eventBus, dbRow?.id, cleanTitle);
 
                     db.markEpisodeStatus(dbRow.id, ep.episode, 'done', filename);
                     ok(`[${cleanTitle}] EP${ep.episode} → ${filename}`);
@@ -375,6 +397,15 @@ async function processAnime(workItem, config, multiBar, auto = false, runQuality
                         err(`[${workItem.title}] EP${ep.episode} failed: ${e.message}`);
                         db.markEpisodeStatus(dbRow.id, ep.episode, 'failed', null, e.message);
                         await notify.notifyFailed(workItem.title, ep.episode, e.message);
+                        if (eventBus) {
+                          eventBus.emit('broadcast', 'episode:failed', {
+                            animeId: dbRow?.id,
+                            title: cleanTitle,
+                            episode: ep.episode,
+                            error: e.message,
+                            willRetry: false,
+                          });
+                        }
                         results.failed++;
                     } else {
                         warn(`[${workItem.title}] EP${ep.episode} attempt ${attempts} failed, retrying...`);
@@ -386,14 +417,24 @@ async function processAnime(workItem, config, multiBar, auto = false, runQuality
     });
 
     await Promise.all(workers);
+
+    if (eventBus) {
+      eventBus.emit('broadcast', 'anime:complete', {
+        animeId: dbRow?.id,
+        title: workItem.title,
+        ...results,
+      });
+    }
+
     return results;
 }
 
 // ── Main cycle ─────────────────────────────────────────────────────────────
 
-async function runCycle({ auto = false, quality = null, language = null, range = null, statuses = null } = {}) {
+async function runCycle({ auto = false, quality = null, language = null, range = null, statuses = null, eventBus = null } = {}) {
     await db.initDb();
     const config = loadConfig();
+    currentBus = eventBus;
 
     console.log(chalk.bold.red('\n  ╔══════════════════════════════════╗'));
     console.log(chalk.bold.red(`  ║  ANI-AUTO v${version} — DOWNLOAD RUN  ║`));
@@ -404,9 +445,11 @@ async function runCycle({ auto = false, quality = null, language = null, range =
         : config;
     const watchList = await resolveWatchList(effectiveConfig);
 
-    if (!watchList.length) {
+        if (!watchList.length) {
         warn('Watch list is empty. Add entries via AniList or `ani-auto add`.');
         db.logRun({ downloaded: 0, skipped: 0, failed: 0, notes: 'empty watch list' });
+        if (eventBus) eventBus.emit('broadcast', 'run:complete', { downloaded: 0, skipped: 0, failed: 0 });
+        currentBus = null;
         return;
     }
 
@@ -418,6 +461,8 @@ async function runCycle({ auto = false, quality = null, language = null, range =
         selected = await promptAnimeSelection(watchList);
         if (!selected.length) {
             warn('No anime selected — exiting.');
+            if (eventBus) eventBus.emit('broadcast', 'run:complete', { downloaded: 0, skipped: 0, failed: 0 });
+            currentBus = null;
             return;
         }
     }
@@ -436,7 +481,7 @@ async function runCycle({ auto = false, quality = null, language = null, range =
     const totals = { downloaded: 0, skipped: 0, failed: 0 };
 
     for (const item of selected) {
-        const result = await processAnime(item, config, multiBar, auto, quality, language, range);
+        const result = await processAnime(item, config, multiBar, auto, quality, language, range, eventBus);
         totals.downloaded += result.downloaded;
         totals.skipped    += result.skipped;
         totals.failed     += result.failed;
@@ -452,8 +497,14 @@ async function runCycle({ auto = false, quality = null, language = null, range =
 
     db.logRun(totals);
     await notify.notifySummary(totals);
+
+    if (eventBus) {
+      eventBus.emit('broadcast', 'run:complete', totals);
+    }
+    currentBus = null;
+    return totals;
 }
 
 function sleep(ms) { return new Promise(r => setTimeout(r, ms)); }
 
-module.exports = { runCycle, resolveWatchList };
+module.exports = { runCycle, resolveWatchList, processAnime };

package/src/scraper.js

@@ -119,8 +119,8 @@ function pickLink(links, quality, language) {
     );
 }
 
-async function downloadEpisode(url, filename, outputDir, multiBar, episodeNum) {
-    await downloadFile(url, filename, outputDir, multiBar, episodeNum);
+async function downloadEpisode(url, filename, outputDir, multiBar, episodeNum, eventBus = null, animeId = null, animeTitle = null) {
+    await downloadFile(url, filename, outputDir, multiBar, episodeNum, eventBus, animeId, animeTitle);
 }
 
 module.exports = { searchAnime, searchAll, getEpisodes, getDownloadLinks, pickLink, downloadEpisode };

package/src/server.js

@@ -0,0 +1,108 @@
+'use strict';
+
+const express = require('express');
+const http = require('http');
+const path = require('path');
+const fs = require('fs');
+const { WebSocketServer } = require('ws');
+const cors = require('cors');
+
+const configRouter = require('./api/config');
+const anilistRouter = require('./api/anilist');
+const animeRouter = require('./api/anime');
+const matchRouter = require('./api/match');
+const downloadRouter = require('./api/download');
+const runsRouter = require('./api/runs');
+const daemonRouter = require('./api/daemon');
+const updateRouter = require('./api/update');
+
+const EventEmitter = require('events');
+const downloadBus = new EventEmitter();
+downloadBus.setMaxListeners(100);
+
+const PORT = process.env.PORT || 2640;
+const CLIENT_DIR = path.join(__dirname, '..', 'web', 'dist');
+
+const app = express();
+app.use(cors());
+app.use(express.json());
+
+app.use('/api/config', configRouter);
+app.use('/api/anilist', anilistRouter);
+app.use('/api/anime', animeRouter);
+app.use('/api/match', matchRouter);
+app.use('/api/runs', runsRouter);
+app.use('/api/daemon', daemonRouter);
+app.use('/api/download', downloadRouter(downloadBus));
+app.use('/api/update', updateRouter);
+
+const cfBypassRouter = require('./api/cf-bypass');
+app.use('/api', cfBypassRouter);
+
+const paheRouter = require('../anime/app');
+const PaheConfig = require('../anime/utils/config');
+const savedConfig = require('./config').loadConfig();
+if (savedConfig.animepaheCfClearance) {
+  PaheConfig.setCfClearance(savedConfig.animepaheCfClearance);
+}
+if (savedConfig.animepaheUserAgent) {
+  PaheConfig.userAgent = savedConfig.animepaheUserAgent;
+}
+app.use('/api/pahe', paheRouter);
+
+app.use(express.static(CLIENT_DIR));
+app.use((req, res) => {
+  if (req.path.startsWith('/api')) return res.status(404).json({ error: 'not found' });
+  res.sendFile(path.join(CLIENT_DIR, 'index.html'), (err) => {
+    if (err) res.status(404).json({ error: 'not found' });
+  });
+});
+
+const server = http.createServer(app);
+const wss = new WebSocketServer({ server, path: '/ws' });
+
+wss.on('connection', (ws) => {
+  ws.on('message', (data) => {
+    try {
+      const msg = JSON.parse(data);
+      if (msg.type === 'download:start') {
+        downloadBus.emit('ws:start', msg, ws);
+      }
+      if (msg.type === 'download:cancel') {
+        downloadBus.emit('ws:cancel');
+      }
+      if (msg.type === 'download:pause') {
+        downloadBus.emit('ws:pause');
+      }
+      if (msg.type === 'download:resume') {
+        downloadBus.emit('ws:resume');
+      }
+    } catch (e) {}
+  });
+});
+
+function broadcast(event, data) {
+  const payload = JSON.stringify({ type: event, ...data });
+  wss.clients.forEach((client) => {
+    if (client.readyState === 1) client.send(payload);
+  });
+}
+
+app.locals.broadcast = broadcast;
+
+downloadBus.on('broadcast', (event, data) => broadcast(event, data));
+
+function startServer() {
+  server.listen(PORT, () => {
+    console.log(`ani-auto web ui running at http://localhost:${PORT}`);
+  });
+}
+
+process.on('SIGINT', () => process.exit(0));
+process.on('SIGTERM', () => process.exit(0));
+
+module.exports = { startServer, downloadBus, broadcast, app };
+
+if (require.main === module) {
+  startServer();
+}

package/utils.js

@@ -16,9 +16,9 @@ function loadConfig() {
 }
 
 const config = loadConfig();
-const API_DOMAIN = config.apiBaseUrl || 'https://aor-rex-anikuro-api.hf.space';
-const SEARCH_API = `${API_DOMAIN}/api/anime/search`;
-const RELEASES_API = `${API_DOMAIN}/api/anime`;
+const API_DOMAIN = `http://localhost:${process.env.PORT || 2640}`;
+const SEARCH_API = `${API_DOMAIN}/api/pahe/search`;
+const RELEASES_API = `${API_DOMAIN}/api/pahe`;
 const USER_AGENT = 'Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Mobile Safari/537.36';
 
 // --- Helpers ---
@@ -36,7 +36,7 @@ const formatBytes = (bytes, decimals = 2) => {
 };
 
 // --- Download Logic ---
-async function downloadFile(url, filename, folder, multiBar, episode) {
+async function downloadFile(url, filename, folder, multiBar, episode, eventBus = null, animeId = null, animeTitle = null) {
     const filePath = path.join(folder, filename);
     let downloadedBytes = 0;
     let fileExists = false;
@@ -107,6 +107,7 @@ async function downloadFile(url, filename, folder, multiBar, episode) {
         let currentProgress = downloadedBytes;
         const startTime = Date.now();
 
+        let lastEmit = 0;
         while (true) {
             const { done, value } = await reader.read();
             if (done) break;
@@ -114,6 +115,22 @@ async function downloadFile(url, filename, folder, multiBar, episode) {
             fileStream.write(Buffer.from(value));
             currentProgress += value.length;
 
+            if (eventBus && (currentProgress - lastEmit > 524288 || currentProgress === downloadedBytes + 1)) {
+                lastEmit = currentProgress;
+                const elapsed = (Date.now() - startTime) / 1000;
+                const speed = elapsed > 0 ? (currentProgress - downloadedBytes) / elapsed : 0;
+                const percent = totalBytes ? Math.round((currentProgress / totalBytes) * 100) : 0;
+                eventBus.emit('broadcast', 'episode:progress', {
+                    animeId,
+                    title: animeTitle,
+                    episode,
+                    percent,
+                    speed: formatBytes(speed) + '/s',
+                    downloaded: currentProgress,
+                    total: totalBytes,
+                });
+            }
+
             if (progressBar) {
                 const elapsed = (Date.now() - startTime) / 1000;
                 const speed = elapsed > 0 ? (currentProgress - downloadedBytes) / elapsed : 0;

package/web/index.html

@@ -0,0 +1,13 @@
+<!DOCTYPE html>
+<html lang="en" class="dark">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <title>ani-auto</title>
+  <link rel="icon" type="image/svg+xml" href="data:image/svg+xml,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 32 32'><text y='28' font-size='28' fill='%23CC0000'>A</text></svg>" />
+</head>
+<body>
+  <div id="app"></div>
+  <script type="module" src="/src/main.js"></script>
+</body>
+</html>