npm - @mostafamohamed18/docker-image-downloader - Versions diffs - 1.0.0 - Mend

@mostafamohamed18/docker-image-downloader 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (4) hide show

package/README.md ADDED Viewed

@@ -0,0 +1,40 @@
+# Docker Image Downloader
+A modern web application to download Docker images directly from Docker Hub without needing Docker installed. The app downloads the image as a `.tar` file compatible with `docker load`.
+## Prerequisites
+- Node.js (v14 or higher)
+## Installation
+1. Open a terminal in this folder.
+2. Install dependencies:
+   ```bash
+   npm install
+   ```
+## Usage
+1. Start the server:
+   ```bash
+   npm start
+   ```
+2. Open your browser and go to:
+   [http://localhost:3000](http://localhost:3000)
+3. Choose a registry (**Docker Hub** or **Chainguard (cgr.dev)**).
+4. Enter an image name and click **Check Tags**.
+   - Docker Hub examples: `nginx`, `redis`, `library/ubuntu`
+   - cgr.dev examples: `chainguard/tomcat` or `cgr.dev/chainguard/tomcat`
+5. Select a version from the dropdown.
+6. Click **Download Image**.
+7. Once downloaded, you can load the image on any machine with Docker:
+   ```bash
+   docker load -i <filename>.tar
+   ```
+## Troubleshooting
+- **Large Images**: Downloading very large images (>2GB) might be slow or hit timeout limits depending on your connection.
+- **Rate Limits**: Docker Hub has rate limits for anonymous pulls. If you encounter errors, retry later.

package/package.json ADDED Viewed

@@ -0,0 +1,37 @@
+{
+  "name": "@mostafamohamed18/docker-image-downloader",
+  "version": "1.0.0",
+  "description": "A modern web application to download Docker images directly from Docker Hub and Chainguard registries without needing Docker installed.",
+  "main": "server.js",
+  "scripts": {
+    "start": "node server.js",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "docker",
+    "image",
+    "downloader",
+    "download",
+    "container",
+    "registry",
+    "dockerhub",
+    "chainguard"
+  ],
+  "author": "Mostafa Mohamed Ali <mostafamhmdali9@gmail.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mostafamohamed18/docker-image-downloader.git"
+  },
+  "bugs": {
+    "url": "https://github.com/mostafamohamed18/docker-image-downloader/issues"
+  },
+  "homepage": "https://github.com/mostafamohamed18/docker-image-downloader#readme",
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "dependencies": {},
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/public/index.html ADDED Viewed

@@ -0,0 +1,468 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Docker Image Downloader</title>
+    <script src="https://cdn.tailwindcss.com"></script>
+    <style>
+        body {
+            background: linear-gradient(135deg, #1b1134, #0f0a1f);
+            color: #ede9fe;
+            font-family: 'Inter', system-ui, -apple-system, sans-serif;
+            min-height: 100vh;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+        }
+        .glass-card {
+            background: rgba(139, 92, 246, 0.08);
+            backdrop-filter: blur(10px);
+            border: 1px solid rgba(167, 139, 250, 0.24);
+            box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.1), 0 2px 4px -1px rgba(0, 0, 0, 0.06);
+        }
+        /* Custom scrollbar for tag list */
+        select::-webkit-scrollbar {
+            width: 8px;
+        }
+        select::-webkit-scrollbar-track {
+            background: #1f1638;
+        }
+        select::-webkit-scrollbar-thumb {
+            background: #7c3aed;
+            border-radius: 4px;
+        }
+        select::-webkit-scrollbar-thumb:hover {
+            background: #8b5cf6;
+        }
+    </style>
+</head>
+<body>
+    <div class="glass-card p-8 rounded-2xl w-full max-w-md space-y-6">
+        <div class="text-center space-y-2">
+            <div class="bg-violet-500/20 p-3 rounded-full w-16 h-16 mx-auto flex items-center justify-center mb-4">
+                <svg xmlns="http://www.w3.org/2000/svg" class="h-8 w-8 text-violet-300" fill="none" viewBox="0 0 24 24" stroke="currentColor">
+                    <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M4 16v1a3 3 0 003 3h10a3 3 0 003-3v-1m-4-4l-4 4m0 0l-4-4m4 4V4" />
+                </svg>
+            </div>
+            <h1 class="text-2xl font-bold bg-clip-text text-transparent bg-gradient-to-r from-violet-300 to-fuchsia-300">Docker Image Downloader</h1>
+            <p class="text-violet-200/80 text-sm">Download images without Docker installed.</p>
+        </div>
+        <div class="space-y-4">
+            <!-- Registry Select -->
+            <div class="space-y-2">
+                <label class="text-sm font-medium text-violet-200 ml-1">Registry</label>
+                <select id="registrySelect" class="w-full bg-violet-950/40 border border-violet-400/30 rounded-lg px-4 py-3 text-violet-100 focus:outline-none focus:ring-2 focus:ring-violet-500/60 transition-all appearance-none cursor-pointer">
+                    <option value="dockerhub" selected>Docker Hub</option>
+                    <option value="cgr">Chainguard (cgr.dev)</option>
+                </select>
+            </div>
+            <!-- Image Input -->
+            <div class="space-y-2">
+                <label class="text-sm font-medium text-violet-200 ml-1">Image Name</label>
+                <div class="relative">
+                    <input type="text" id="imageInput" placeholder="e.g. nginx, ubuntu, library/redis"
+                        class="w-full bg-violet-950/40 border border-violet-400/30 rounded-lg px-4 py-3 text-violet-100 focus:outline-none focus:ring-2 focus:ring-violet-500/60 focus:border-violet-400 transition-all placeholder:text-violet-300/45">
+                    <button id="checkTagsBtn" class="absolute right-2 top-2 bottom-2 px-3 bg-violet-700/70 hover:bg-violet-600/80 rounded text-xs font-medium transition-colors text-violet-100">
+                        Check Tags
+                    </button>
+                </div>
+            </div>
+            <!-- Tags Select -->
+            <div class="space-y-2 transition-all duration-300 transform origin-top hidden" id="tagsContainer">
+                <label class="text-sm font-medium text-violet-200 ml-1">Select Tag</label>
+                <select id="tagSelect" class="w-full bg-violet-950/40 border border-violet-400/30 rounded-lg px-4 py-3 text-violet-100 focus:outline-none focus:ring-2 focus:ring-violet-500/60 transition-all appearance-none cursor-pointer">
+                    <option value="" disabled selected>Choose a version...</option>
+                </select>
+                <div class="relative w-full">
+                     <div class="absolute right-4 top-[-2.2rem] pointer-events-none text-violet-300/60">
+                        <svg xmlns="http://www.w3.org/2000/svg" class="h-5 w-5" fill="none" viewBox="0 0 24 24" stroke="currentColor">
+                            <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M19 9l-7 7-7-7" />
+                        </svg>
+                    </div>
+                </div>
+            </div>
+            <!-- Download Button -->
+            <button id="downloadBtn" disabled
+                class="w-full bg-gradient-to-r from-violet-700 to-fuchsia-700 hover:from-violet-600 hover:to-fuchsia-600 disabled:opacity-50 disabled:cursor-not-allowed text-white font-semibold py-3.5 rounded-lg shadow-lg shadow-violet-900/40 transition-all transform active:scale-[0.98] flex items-center justify-center gap-2 group">
+                <span>Download Image</span>
+                <svg xmlns="http://www.w3.org/2000/svg" class="h-5 w-5 group-hover:translate-y-1 transition-transform" fill="none" viewBox="0 0 24 24" stroke="currentColor">
+                    <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M4 16v1a3 3 0 003 3h10a3 3 0 003-3v-1m-4-4l-4 4m0 0l-4-4m4 4V4" />
+                </svg>
+            </button>
+            <!-- Status/Progress -->
+            <div id="status" class="hidden text-center text-sm p-3 rounded-lg bg-violet-950/35 border border-violet-400/20 text-violet-200/80">
+                Ready to start.
+            </div>
+        </div>
+    </div>
+    <div id="debugPanel" class="fixed bottom-4 left-4 w-[min(92vw,34rem)] max-h-56 overflow-auto text-xs bg-black/50 border border-violet-400/30 rounded-lg p-3 text-violet-100/90 backdrop-blur-sm hidden">
+        <div class="flex items-center justify-between mb-2">
+            <span class="font-semibold">Debug Log</span>
+            <div class="flex gap-3">
+                <button id="testBackendBtn" class="text-violet-200 hover:text-white text-xs">Test Backend</button>
+                <button id="clearDebugBtn" class="text-violet-200 hover:text-white text-xs">Clear</button>
+            </div>
+        </div>
+        <pre id="debugLog" class="whitespace-pre-wrap break-words"></pre>
+    </div>
+    <a href="https://github.com/mostafamohamed18" target="_blank" rel="noopener noreferrer" class="fixed bottom-4 right-4 text-sm text-violet-200/85 hover:text-violet-100 bg-violet-900/35 border border-violet-400/25 rounded-lg px-3 py-2 backdrop-blur-sm transition-colors">
+        github.com/mostafamohamed18
+    </a>
+    <script>
+        const registrySelect = document.getElementById('registrySelect');
+        const imageInput = document.getElementById('imageInput');
+        const checkTagsBtn = document.getElementById('checkTagsBtn');
+        const tagsContainer = document.getElementById('tagsContainer');
+        const tagSelect = document.getElementById('tagSelect');
+        const downloadBtn = document.getElementById('downloadBtn');
+        const statusDiv = document.getElementById('status');
+        const debugPanel = document.getElementById('debugPanel');
+        const debugLog = document.getElementById('debugLog');
+        const clearDebugBtn = document.getElementById('clearDebugBtn');
+        const testBackendBtn = document.getElementById('testBackendBtn');
+        let lastApiAttemptUrls = [];
+        let resolvedImageName = null;
+        function appendDebug(message, data) {
+            debugPanel.classList.remove('hidden');
+            const time = new Date().toISOString();
+            const serialized = data ? ` ${JSON.stringify(data)}` : '';
+            debugLog.textContent += `[${time}] ${message}${serialized}\n`;
+            debugPanel.scrollTop = debugPanel.scrollHeight;
+        }
+        clearDebugBtn.addEventListener('click', () => {
+            debugLog.textContent = '';
+        });
+        async function runBackendDiagnostics() {
+            appendDebug('diag.start', {
+                pageOrigin: window.location.origin,
+                href: window.location.href,
+                online: navigator.onLine,
+                userAgent: navigator.userAgent
+            });
+            const endpoints = [
+                '/api/health',
+                '/api/debug/ping?source=ui',
+                '/api/tags?registry=cgr&image=cgr.dev/chainguard/tomcat:latest'
+            ];
+            for (const endpoint of endpoints) {
+                const candidates = getApiCandidates(endpoint);
+                for (const apiUrl of candidates) {
+                    try {
+                        appendDebug('diag.try', { endpoint, apiUrl });
+                        const response = await fetch(apiUrl);
+                        const text = await response.text();
+                        appendDebug('diag.result', {
+                            endpoint,
+                            apiUrl,
+                            status: response.status,
+                            bodySnippet: text.substring(0, 300)
+                        });
+                    } catch (err) {
+                        appendDebug('diag.error', {
+                            endpoint,
+                            apiUrl,
+                            name: err?.name,
+                            message: err?.message
+                        });
+                    }
+                }
+            }
+            appendDebug('diag.done');
+        }
+        testBackendBtn.addEventListener('click', async () => {
+            testBackendBtn.disabled = true;
+            testBackendBtn.textContent = 'Testing...';
+            try {
+                await runBackendDiagnostics();
+            } finally {
+                testBackendBtn.disabled = false;
+                testBackendBtn.textContent = 'Test Backend';
+            }
+        });
+        appendDebug('debug.init', {
+            pageOrigin: window.location.origin,
+            pageHref: window.location.href,
+            online: navigator.onLine
+        });
+        function getApiCandidates(pathWithQuery) {
+            const { protocol, hostname, origin } = window.location;
+            const isHttpPage = protocol === 'http:' || protocol === 'https:';
+            const candidates = [];
+            if (isHttpPage) {
+                candidates.push(`${origin}${pathWithQuery}`);
+            }
+            const localhostUrl = `http://localhost:3000${pathWithQuery}`;
+            const sameAsLocalhost3000 = isHttpPage && (origin === 'http://localhost:3000' || origin === 'http://127.0.0.1:3000');
+            if (!sameAsLocalhost3000) {
+                candidates.push(localhostUrl);
+            }
+            const uniqueCandidates = [...new Set(candidates)];
+            appendDebug('api.candidates', { pathWithQuery, uniqueCandidates, origin: window.location.origin });
+            return uniqueCandidates;
+        }
+        async function fetchFromApi(pathWithQuery) {
+            const candidates = getApiCandidates(pathWithQuery);
+            let lastError = null;
+            lastApiAttemptUrls = candidates;
+            for (const apiUrl of candidates) {
+                try {
+                    appendDebug('api.try', { apiUrl });
+                    const res = await fetch(apiUrl);
+                    appendDebug('api.response', { apiUrl, status: res.status, ok: res.ok });
+                    return res;
+                } catch (err) {
+                    lastError = err;
+                    appendDebug('api.fetch.error', {
+                        apiUrl,
+                        name: err?.name,
+                        message: err?.message
+                    });
+                }
+            }
+            throw lastError || new Error('Unable to reach API');
+        }
+        function stripTagOrDigest(imageName) {
+            if (!imageName) return imageName;
+            let normalized = imageName.split('@')[0];
+            const lastSlash = normalized.lastIndexOf('/');
+            const lastColon = normalized.lastIndexOf(':');
+            if (lastColon > lastSlash) {
+                normalized = normalized.substring(0, lastColon);
+            }
+            return normalized;
+        }
+        function sanitizeImageInput(imageName) {
+            if (!imageName) return imageName;
+            let sanitized = imageName.trim();
+            sanitized = sanitized.replace(/^(docker|podman)\s+pull\s+/i, '');
+            sanitized = sanitized.replace(/^https?:\/\//i, '');
+            sanitized = sanitized.replace(/^['\"]+|['\"]+$/g, '');
+            sanitized = sanitized.split(/\s+/)[0];
+            sanitized = sanitized.replace(/^['\"]+|['\"]+$/g, '');
+            return sanitized;
+        }
+        function getNormalizedImageName(image, registry) {
+            const cleanImage = sanitizeImageInput(image);
+            if (registry === 'cgr') {
+                return cleanImage.replace(/^cgr\.dev\//i, '');
+            }
+            return cleanImage.replace(/^docker\.io\//i, '');
+        }
+        function getRepositoryName(image, registry) {
+            const normalized = getNormalizedImageName(image, registry);
+            return stripTagOrDigest(normalized);
+        }
+        function getImageReferenceForDownload(image, registry) {
+            const normalized = getRepositoryName(image, registry);
+            if (registry === 'cgr') {
+                return `cgr.dev/${normalized}`;
+            }
+            return normalized;
+        }
+        function updateImagePlaceholder() {
+            if (registrySelect.value === 'cgr') {
+                imageInput.placeholder = 'e.g. tomcat, chainguard/tomcat, or cgr.dev/chainguard/tomcat';
+            } else {
+                imageInput.placeholder = 'e.g. nginx, ubuntu, library/redis';
+            }
+        }
+        imageInput.addEventListener('input', () => {
+            const value = sanitizeImageInput(imageInput.value).toLowerCase();
+            if (value.startsWith('cgr.dev/')) {
+                registrySelect.value = 'cgr';
+                updateImagePlaceholder();
+            }
+        });
+        registrySelect.addEventListener('change', () => {
+            updateImagePlaceholder();
+            tagsContainer.classList.add('hidden');
+            tagSelect.innerHTML = '<option value="" disabled selected>Choose a version...</option>';
+            downloadBtn.disabled = true;
+            resolvedImageName = null;
+            statusDiv.classList.add('hidden');
+        });
+        updateImagePlaceholder();
+        // Handle Check Tags
+        checkTagsBtn.addEventListener('click', async () => {
+            const image = sanitizeImageInput(imageInput.value);
+            const registry = registrySelect.value;
+            if (!image) {
+                showStatus('Please enter an image name first.', 'error');
+                return;
+            }
+            const normalizedImage = getRepositoryName(image, registry);
+            if (!normalizedImage) {
+                showStatus('Please enter a valid image name.', 'error');
+                return;
+            }
+            checkTagsBtn.textContent = '...';
+            checkTagsBtn.disabled = true;
+            statusDiv.classList.add('hidden');
+            try {
+                const res = await fetchFromApi(`/api/tags?registry=${encodeURIComponent(registry)}&image=${encodeURIComponent(normalizedImage)}`);
+                if (!res.ok) {
+                    const bodyText = await res.text();
+                    appendDebug('api.http.notOk', { status: res.status, bodyText: bodyText.substring(0, 500) });
+                    throw new Error(`HTTP ${res.status}`);
+                }
+                const data = await res.json();
+                appendDebug('api.json', {
+                    hasError: Boolean(data.error),
+                    tagCount: Array.isArray(data.tags) ? data.tags.length : 0,
+                    resolvedImage: data.resolvedImage || null,
+                    autoCorrected: Boolean(data.autoCorrected)
+                });
+                if (data.error) throw new Error(data.error);
+                resolvedImageName = data.resolvedImage || normalizedImage;
+                // Populate tags
+                tagSelect.innerHTML = '<option value="" disabled selected>Choose a version...</option>';
+                // Sort tags? Maybe latest first.
+                // Simple sort logic: prioritize 'latest', then semantic versions descending
+                const tags = data.tags.sort((a,b) => {
+                     if (a === 'latest') return -1;
+                     if (b === 'latest') return 1;
+                     return b.localeCompare(a, undefined, { numeric: true, sensitivity: 'base' });
+                });
+                tags.forEach(tag => {
+                    const option = document.createElement('option');
+                    option.value = tag;
+                    option.textContent = tag;
+                    tagSelect.appendChild(option);
+                });
+                tagsContainer.classList.remove('hidden');
+                tagsContainer.classList.remove('origin-top');
+                tagsContainer.classList.add('animate-fade-in-down'); // if using animation classes
+                if (data.autoCorrected && data.resolvedImage) {
+                    showStatus(`Found ${tags.length} tags. Using closest match: ${data.resolvedImage}.`, 'success');
+                } else if (data.resolvedImage && data.resolvedImage !== normalizedImage) {
+                    showStatus(`Found ${tags.length} tags. Resolved image: ${data.resolvedImage}.`, 'success');
+                } else {
+                    showStatus(`Found ${tags.length} tags.`, 'success');
+                }
+                checkTagsBtn.textContent = 'Updated';
+                setTimeout(() => { checkTagsBtn.textContent = 'Check Tags'; checkTagsBtn.disabled = false; }, 2000);
+            } catch (err) {
+                console.error(err);
+                appendDebug('checkTags.catch', {
+                    name: err?.name,
+                    message: err?.message,
+                    attemptedUrls: lastApiAttemptUrls
+                });
+                if (err instanceof TypeError) {
+                    showStatus('Error fetching tags: Backend is unreachable. Start server and open the app at http://localhost:3000 (not another port).', 'error');
+                } else {
+                    showStatus('Error fetching tags: ' + err.message, 'error');
+                }
+                checkTagsBtn.textContent = 'Check Tags';
+                checkTagsBtn.disabled = false;
+            }
+        });
+        // Handle Tag Selection
+        tagSelect.addEventListener('change', () => {
+            if (tagSelect.value) {
+                downloadBtn.disabled = false;
+            }
+        });
+        // Handle Download
+        downloadBtn.addEventListener('click', async () => {
+                             const image = sanitizeImageInput(imageInput.value);
+               const registry = registrySelect.value;
+             const tag = tagSelect.value;
+             if (!image || !tag) return;
+                             const imageRef = getImageReferenceForDownload(resolvedImageName || image, registry);
+             downloadBtn.disabled = true;
+             downloadBtn.innerHTML = `<svg class="animate-spin -ml-1 mr-3 h-5 w-5 text-white" xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24"><circle class="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" stroke-width="4"></circle><path class="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z"></path></svg> Downloading...`;
+             showStatus('Starting download... This may take a while depending on image size.', 'info');
+             try {
+                // Redirect user to the external downloader service
+                // Using dockerimagesave.akiel.dev as requested
+                const downloadUrl = `https://dockerimagesave.akiel.dev/image?name=${encodeURIComponent(imageRef)}:${encodeURIComponent(tag)}`;
+                showStatus('Redirecting to download service...', 'info');
+                // Open in new tab or same window? New tab is safer for downloads usually.
+                window.location.href = downloadUrl;
+                // Reset button after a delay
+                setTimeout(() => {
+                    downloadBtn.disabled = false;
+                    downloadBtn.innerHTML = `<span>Download Again</span> <svg xmlns="http://www.w3.org/2000/svg" class="h-5 w-5" fill="none" viewBox="0 0 24 24" stroke="currentColor"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M4 16v1a3 3 0 003 3h10a3 3 0 003-3v-1m-4-4l-4 4m0 0l-4-4m4 4V4" /></svg>`;
+                    showStatus('Download started! Check your browser downloads.', 'success');
+                }, 3000);
+             } catch (err) {
+                 showStatus('Error: ' + err.message, 'error');
+                 downloadBtn.disabled = false;
+                 downloadBtn.textContent = 'Download Image';
+             }
+        });
+        function showStatus(msg, type) {
+            statusDiv.textContent = msg;
+            statusDiv.classList.remove('hidden');
+            statusDiv.className = 'text-center text-sm p-3 rounded-lg border'; // reset
+            if (type === 'error') {
+                statusDiv.classList.add('bg-red-500/10', 'border-red-500/20', 'text-red-400');
+            } else if (type === 'success') {
+                statusDiv.classList.add('bg-green-500/10', 'border-green-500/20', 'text-green-400');
+            } else {
+                statusDiv.classList.add('bg-violet-500/10', 'border-violet-500/25', 'text-violet-300');
+            }
+        }
+    </script>
+</body>
+</html>

package/server.js ADDED Viewed

@@ -0,0 +1,528 @@
+const http = require('http');
+const https = require('https');
+const fs = require('fs');
+const path = require('path');
+const url = require('url');
+const PORT = 3000;
+const PUBLIC_DIR = path.join(__dirname, 'public');
+const SERVER_STARTED_AT = new Date().toISOString();
+const CGR_KNOWN_REPOS = [
+    'chainguard/tomcat',
+    'chainguard/nginx',
+    'chainguard/redis',
+    'chainguard/postgres',
+    'chainguard/mysql',
+    'chainguard/mariadb',
+    'chainguard/node',
+    'chainguard/python',
+    'chainguard/java',
+    'chainguard/jre',
+    'chainguard/jdk',
+    'chainguard/go',
+    'chainguard/ruby',
+    'chainguard/php',
+    'chainguard/busybox',
+    'chainguard/curl',
+    'chainguard/git',
+    'chainguard/kubectl',
+    'chainguard/maven',
+    'chainguard/gradle'
+];
+// --- Helper Functions ---
+const mimeTypes = {
+    '.html': 'text/html',
+    '.css': 'text/css',
+    '.js': 'text/javascript',
+    '.json': 'application/json',
+    '.png': 'image/png',
+    '.svg': 'image/svg+xml'
+};
+function sendJson(res, status, data) {
+    res.writeHead(status, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify(data));
+}
+function logDebug(context, details = {}) {
+    const ts = new Date().toISOString();
+    console.log(`[${ts}] [${context}] ${JSON.stringify(details)}`);
+}
+function httpsGetResponse(urlStr, headers = {}) {
+    return new Promise((resolve, reject) => {
+        logDebug('https.request.start', {
+            url: urlStr,
+            hasAuthorization: Boolean(headers.Authorization)
+        });
+        const urlObj = url.parse(urlStr);
+        const options = {
+            hostname: urlObj.hostname,
+            path: urlObj.path,
+            method: 'GET',
+            headers: headers,
+            rejectUnauthorized: false // Bypass SSL errors (self-signed certs)
+        };
+        const req = https.request(options, (res) => {
+            let data = '';
+            res.on('data', chunk => data += chunk);
+            res.on('end', () => {
+                logDebug('https.request.end', {
+                    url: urlStr,
+                    statusCode: res.statusCode,
+                    bodySnippet: (data || '').substring(0, 180)
+                });
+                resolve({
+                    statusCode: res.statusCode,
+                    headers: res.headers,
+                    body: data
+                });
+            });
+        });
+        req.on('error', e => {
+            logDebug('https.request.error', {
+                url: urlStr,
+                error: e.message
+            });
+            reject(e);
+        });
+        req.end();
+    });
+}
+function httpsGet(urlStr, headers = {}) {
+    return httpsGetResponse(urlStr, headers)
+        .then(response => {
+            if (response.statusCode >= 400) {
+                // Try to parse error message if JSON
+                try {
+                    const json = JSON.parse(response.body);
+                    throw new Error(json.message || json.error || `HTTP ${response.statusCode}`);
+                } catch (e) {
+                    if (e instanceof Error && !e.message.startsWith('Unexpected token')) {
+                        throw e;
+                    }
+                    throw new Error(`HTTP ${response.statusCode}: ${response.body.substring(0, 100)}`);
+                }
+            }
+            return response.body;
+        });
+}
+function parseWwwAuthenticateBearer(headerValue) {
+    if (!headerValue) return null;
+    const match = headerValue.match(/^Bearer\s+(.+)$/i);
+    if (!match) return null;
+    const params = {};
+    const regex = /(\w+)="([^"]*)"/g;
+    let pair;
+    while ((pair = regex.exec(match[1])) !== null) {
+        params[pair[1]] = pair[2];
+    }
+    return {
+        realm: params.realm,
+        service: params.service,
+        scope: params.scope
+    };
+}
+function stripTagOrDigest(imageName) {
+    if (!imageName) return imageName;
+    let normalized = imageName.split('@')[0];
+    const lastSlash = normalized.lastIndexOf('/');
+    const lastColon = normalized.lastIndexOf(':');
+    if (lastColon > lastSlash) {
+        normalized = normalized.substring(0, lastColon);
+    }
+    return normalized;
+}
+function sanitizeImageInput(imageName) {
+    if (!imageName) return imageName;
+    let sanitized = imageName.trim();
+    sanitized = sanitized.replace(/^(docker|podman)\s+pull\s+/i, '');
+    sanitized = sanitized.replace(/^https?:\/\//i, '');
+    sanitized = sanitized.replace(/^['\"]+|['\"]+$/g, '');
+    sanitized = sanitized.split(/\s+/)[0];
+    sanitized = sanitized.replace(/^['\"]+|['\"]+$/g, '');
+    return sanitized;
+}
+function isValidRepoName(repoName, registry) {
+    if (!repoName) return false;
+    const cgrPattern = /^[a-z0-9]+(?:[._-][a-z0-9]+)*(?:\/[a-z0-9]+(?:[._-][a-z0-9]+)*)+$/i;
+    const dockerPattern = /^[a-z0-9]+(?:[._-][a-z0-9]+)*(?:\/[a-z0-9]+(?:[._-][a-z0-9]+)*)*$/i;
+    if (registry === 'cgr') {
+        return cgrPattern.test(repoName);
+    }
+    return dockerPattern.test(repoName);
+}
+function levenshteinDistance(a, b) {
+    const source = (a || '').toLowerCase();
+    const target = (b || '').toLowerCase();
+    const matrix = Array.from({ length: source.length + 1 }, () => Array(target.length + 1).fill(0));
+    for (let i = 0; i <= source.length; i += 1) matrix[i][0] = i;
+    for (let j = 0; j <= target.length; j += 1) matrix[0][j] = j;
+    for (let i = 1; i <= source.length; i += 1) {
+        for (let j = 1; j <= target.length; j += 1) {
+            const cost = source[i - 1] === target[j - 1] ? 0 : 1;
+            matrix[i][j] = Math.min(
+                matrix[i - 1][j] + 1,
+                matrix[i][j - 1] + 1,
+                matrix[i - 1][j - 1] + cost
+            );
+        }
+    }
+    return matrix[source.length][target.length];
+}
+function findBestCgrRepoMatch(inputRepo) {
+    const normalized = (inputRepo || '').toLowerCase();
+    const inputLeaf = normalized.split('/').pop() || normalized;
+    let best = null;
+    for (const repo of CGR_KNOWN_REPOS) {
+        const repoLower = repo.toLowerCase();
+        const repoLeaf = repoLower.split('/').pop();
+        const fullDistance = levenshteinDistance(normalized, repoLower);
+        const leafDistance = levenshteinDistance(inputLeaf, repoLeaf);
+        const score = Math.min(fullDistance, leafDistance);
+        if (!best || score < best.score) {
+            best = { repo, score };
+        }
+    }
+    if (!best) return null;
+    if (best.score <= 2) return best.repo;
+    return null;
+}
+function buildCgrCandidates(imageName) {
+    const rawRepo = stripTagOrDigest(imageName.replace(/^cgr\.dev\//i, ''));
+    const candidates = [];
+    if (rawRepo.includes('/')) {
+        candidates.push(rawRepo);
+    } else {
+        candidates.push(`chainguard/${rawRepo}`);
+    }
+    const bestMatch = findBestCgrRepoMatch(rawRepo);
+    if (bestMatch && !candidates.includes(bestMatch)) {
+        candidates.push(bestMatch);
+    }
+    return {
+        rawRepo,
+        candidates: [...new Set(candidates)]
+    };
+}
+function resolveRegistry(imageName, requestedRegistry) {
+    const normalized = sanitizeImageInput(imageName).toLowerCase();
+    if (normalized.startsWith('cgr.dev/')) return 'cgr';
+    if (normalized.startsWith('docker.io/') || normalized.startsWith('registry-1.docker.io/')) return 'dockerhub';
+    return requestedRegistry;
+}
+function fetchDockerHubTags(imageName) {
+    let repo = stripTagOrDigest(imageName);
+    repo = repo.replace(/^docker\.io\//i, '').replace(/^registry-1\.docker\.io\//i, '');
+    if (!repo.includes('/')) repo = `library/${repo}`;
+    if (!isValidRepoName(repo, 'dockerhub')) {
+        throw new Error('Invalid Docker Hub image name format');
+    }
+    logDebug('dockerhub.tags.start', { input: imageName, repo });
+    // 1. Get Auth Token
+    const authUrl = `https://auth.docker.io/token?service=registry.docker.io&scope=repository:${repo}:pull`;
+    return httpsGet(authUrl)
+        .then(authData => {
+            try {
+                const token = JSON.parse(authData).token;
+                if (!token) throw new Error('No token in auth response');
+                return token;
+            } catch (e) {
+                throw new Error('Auth parse failed: ' + e.message);
+            }
+        })
+        .then(token => {
+            // 2. Get Tags
+            const tagsUrl = `https://registry-1.docker.io/v2/${repo}/tags/list`;
+            logDebug('dockerhub.tags.fetch', { repo, tagsUrl });
+            return httpsGet(tagsUrl, { 'Authorization': `Bearer ${token}` });
+        })
+        .then(tagsData => {
+            try {
+                const json = JSON.parse(tagsData);
+                return { tags: json.tags || [], resolvedImage: repo };
+            } catch (e) {
+                throw new Error('Tags parse failed');
+            }
+        });
+}
+function fetchCgrTagsForRepo(repo) {
+    const tagsUrl = `https://cgr.dev/v2/${repo}/tags/list`;
+    return httpsGetResponse(tagsUrl)
+        .then(response => {
+            if (response.statusCode < 400) {
+                return response.body;
+            }
+            if (response.statusCode !== 401) {
+                logDebug('cgr.tags.unexpectedStatus', {
+                    repo,
+                    statusCode: response.statusCode,
+                    bodySnippet: (response.body || '').substring(0, 180)
+                });
+                throw new Error(`HTTP ${response.statusCode}: ${response.body.substring(0, 100)}`);
+            }
+            const challenge = parseWwwAuthenticateBearer(response.headers['www-authenticate']);
+            if (!challenge || !challenge.realm) {
+                throw new Error('cgr.dev auth challenge missing or invalid');
+            }
+            const authUrlObj = url.parse(challenge.realm, true);
+            authUrlObj.query = authUrlObj.query || {};
+            if (challenge.service) authUrlObj.query.service = challenge.service;
+            if (challenge.scope) {
+                authUrlObj.query.scope = challenge.scope;
+            } else {
+                authUrlObj.query.scope = `repository:${repo}:pull`;
+            }
+            delete authUrlObj.search;
+            const authUrl = url.format(authUrlObj);
+            logDebug('cgr.auth.challenge', {
+                repo,
+                realm: challenge.realm,
+                service: challenge.service,
+                scope: authUrlObj.query.scope
+            });
+            return httpsGet(authUrl)
+                .then(authData => {
+                    let token;
+                    try {
+                        const authJson = JSON.parse(authData);
+                        token = authJson.token || authJson.access_token;
+                    } catch (e) {
+                        throw new Error('Auth parse failed');
+                    }
+                    if (!token) {
+                        throw new Error('No token in cgr.dev auth response');
+                    }
+                    logDebug('cgr.tags.fetch', { repo, tagsUrl, hasToken: true });
+                    return httpsGet(tagsUrl, { 'Authorization': `Bearer ${token}` });
+                });
+        });
+}
+function fetchCgrTags(imageName) {
+    const { rawRepo, candidates } = buildCgrCandidates(imageName);
+    if (!rawRepo) {
+        throw new Error('Invalid cgr.dev image name');
+    }
+    logDebug('cgr.tags.start', { input: imageName, rawRepo, candidates });
+    let sequence = Promise.reject(new Error('No cgr candidates to try'));
+    candidates.forEach((candidateRepo) => {
+        sequence = sequence.catch(() => {
+            if (!isValidRepoName(candidateRepo, 'cgr')) {
+                throw new Error(`Invalid cgr.dev image name format: ${candidateRepo}`);
+            }
+            return fetchCgrTagsForRepo(candidateRepo)
+                .then(tagsData => {
+                    const json = JSON.parse(tagsData);
+                    return {
+                        tags: json.tags || [],
+                        resolvedImage: candidateRepo,
+                        autoCorrected: candidateRepo.toLowerCase() !== rawRepo.toLowerCase()
+                    };
+                });
+        });
+    });
+    return sequence.catch((err) => {
+        throw new Error(err.message || 'Failed to fetch cgr.dev tags');
+    });
+}
+function fetchTags(imageName, registry = 'dockerhub') {
+    const sanitizedImageName = sanitizeImageInput(imageName);
+    logDebug('tags.dispatch', { imageName, sanitizedImageName, registry });
+    if (registry === 'cgr') {
+        return fetchCgrTags(sanitizedImageName);
+    }
+    return fetchDockerHubTags(sanitizedImageName);
+}
+// --- HTTP Server ---
+const server = http.createServer((req, res) => {
+    // Set CORS headers
+    res.setHeader('Access-Control-Allow-Origin', '*');
+    res.setHeader('Access-Control-Allow-Methods', 'GET, OPTIONS');
+    if (req.method === 'OPTIONS') {
+        res.writeHead(204);
+        res.end();
+        return;
+    }
+    const parsedUrl = url.parse(req.url, true);
+    let pathname = parsedUrl.pathname;
+    if (pathname === '/api/health') {
+        sendJson(res, 200, {
+            ok: true,
+            service: 'docker-image-downloader',
+            startedAt: SERVER_STARTED_AT,
+            now: new Date().toISOString(),
+            uptimeSeconds: Math.round(process.uptime())
+        });
+        return;
+    }
+    if (pathname === '/api/debug/ping') {
+        sendJson(res, 200, {
+            ok: true,
+            method: req.method,
+            url: req.url,
+            query: parsedUrl.query,
+            headers: {
+                host: req.headers.host,
+                origin: req.headers.origin || null,
+                referer: req.headers.referer || null,
+                userAgent: req.headers['user-agent'] || null
+            },
+            now: new Date().toISOString()
+        });
+        return;
+    }
+    // API: /api/tags
+    if (pathname === '/api/tags') {
+        const image = parsedUrl.query.image;
+        const sanitizedImage = sanitizeImageInput(image);
+        const requestedRegistry = (parsedUrl.query.registry || 'dockerhub').toLowerCase();
+        const requestId = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+        logDebug('api.tags.request', {
+            requestId,
+            image,
+            sanitizedImage,
+            requestedRegistry,
+            rawQuery: parsedUrl.query
+        });
+        if (!sanitizedImage) {
+            sendJson(res, 400, { error: 'Image name required' });
+            return;
+        }
+        if (!['dockerhub', 'cgr'].includes(requestedRegistry)) {
+            sendJson(res, 400, { error: 'Unsupported registry' });
+            return;
+        }
+        const registry = resolveRegistry(sanitizedImage, requestedRegistry);
+        logDebug('api.tags.resolved', { requestId, registry, requestedRegistry, image, sanitizedImage });
+        fetchTags(sanitizedImage, registry)
+            .then(data => {
+                logDebug('api.tags.success', {
+                    requestId,
+                    registry,
+                    tagCount: Array.isArray(data.tags) ? data.tags.length : 0
+                });
+                sendJson(res, 200, data);
+            })
+            .catch(err => {
+                logDebug('api.tags.error', {
+                    requestId,
+                    registry,
+                    error: err.message
+                });
+                // Return empty list on error so UI can still function manually
+                sendJson(res, 200, { tags: [], error: err.message });
+            });
+        return;
+    }
+    // Serve Static Files
+    if (pathname === '/') pathname = '/index.html';
+    // Prevent directory traversal
+    const safePath = path.normalize(pathname).replace(/^(\.\.[\/\\])+/, '');
+    const filePath = path.join(PUBLIC_DIR, safePath);
+    fs.readFile(filePath, (err, content) => {
+        if (err) {
+            if (err.code === 'ENOENT') {
+                res.writeHead(404);
+                res.end('<h1>404 Not Found</h1>');
+            } else {
+                res.writeHead(500);
+                res.end(`Server Error: ${err.code}`);
+            }
+        } else {
+            const ext = path.extname(filePath);
+            const contentType = mimeTypes[ext] || 'application/octet-stream';
+            res.writeHead(200, { 'Content-Type': contentType });
+            res.end(content);
+        }
+    });
+});
+// Start Server
+server.listen(PORT, () => {
+    console.log(`Server running at http://localhost:${PORT}`);
+    console.log('Mode: Zero-Dependency (using built-in http/https)');
+});
+server.on('error', (err) => {
+    logDebug('server.error', {
+        code: err.code,
+        message: err.message,
+        port: PORT
+    });
+    console.error('Server failed to start:', err.message);
+});
+process.on('uncaughtException', (err) => {
+    logDebug('process.uncaughtException', {
+        message: err.message,
+        stack: err.stack
+    });
+});
+process.on('unhandledRejection', (reason) => {
+    const message = reason instanceof Error ? reason.message : String(reason);
+    const stack = reason instanceof Error ? reason.stack : null;
+    logDebug('process.unhandledRejection', { message, stack });
+});