Enhance domain checking functionality and update Dockerfile

- Added support for WHOIS and RDAP checks for domain availability.
- Implemented handling for unsupported TLDs.
- Updated Dockerfile to install necessary packages.
- Modified HTML and JavaScript for improved user experience and API integration.

Dockerfile

@@ -11,6 +11,8 @@ COPY --chown=user ./requirements.txt requirements.txt
 
 RUN pip install --no-cache-dir --upgrade -r requirements.txt
 
+RUN apt-get -y update && apt-get -y install whois && apt-get -y install netbase
+
 COPY --chown=user . /app
 
 CMD ["gunicorn", "-b", "0.0.0.0:7860", "app:app"]

app.py

@@ -5,8 +5,17 @@ import requests
 from urllib.parse import urlparse
 import dns.resolver
 import socket
+import platform
+import subprocess
+from shutil import which
 
 app = Flask(__name__)
+unsupported_TLDs = [
+    {
+        "tld": '.ly',
+        "check": "https://reg.ly/ly-domain/"
+    }
+]
 
 @app.route('/')
 def index():
@@ -16,95 +25,82 @@ def index():
     except Exception as e:
         return str(e)
 
-@app.route('/check', methods=['POST'])
-def check_domain():
+@app.route('/check/<domain>', methods=['POST'])
+def check_domain(domain: str):
     """Check domain availability"""
     try:
-        domain = request.json.get('domain', '').strip().lower().strip('/')
+        domain = domain.lower().strip('/').strip()
         if '://' in domain:
             domain = urlparse(domain).netloc
-        result = check_domain_availability(domain) or {}
-        return {
-            "domain": domain,
-            "available": result.get("available"),
-            "method": result.get("method", None),
-            "error": result.get("error", None)
-        }
-    except Exception as e:
-        return { "domain": domain, "error": str(e) }
+
+        for unsupported_TLD in unsupported_TLDs:
+            if domain.endswith(unsupported_TLD.get('tld', '')):
+                return { 
+                    'domain': domain, 
+                    "available": False, 
+                    "method": "Unsupported TLD"
+                }
+
+        result = check_domain_availability(domain)
+        if result:
+            return { "domain": domain, **result }
+    except:
+        pass
+    return { 
+        'domain': domain, 
+        "available": False, 
+        "method": "Cannot confirm if doimain is available"
+    }
 
 def check_domain_availability(domain):
     """Check domain availability using multiple methods."""
     # First try DNS resolution
-    dns_exists, record_type = check_dns_records(domain)
-    if dns_exists:
-        return { "available": False, "method": f"DNS:{record_type}" }
+    is_available, availability_method, _continue = dns_is_available(domain)
+    if not _continue:
+        return { "available": is_available, "method": f"DNS:{availability_method}" }
     
     # Try RDAP
-    rdap_status_code, rdap_base_url = check_rdap_records(domain)
-    if rdap_status_code == 404:
-        return { "available": True, "method": f"RDAP:{rdap_base_url}" }
-    elif rdap_status_code == 200:
-        return { "available": False, "method": f"RDAP:{rdap_base_url}" }
+    is_available, availability_method, _continue = rdap_is_available(domain)
+    if not _continue:
+        return { "available": is_available, "method": f"RDAP:{availability_method}" }
 
     # Fall back to WHOIS
-    whois_server = get_whois_server(domain)
-    if whois_server and no_whois_records(domain, whois_server):
-        return {"available": True, "method": f"WHOIS:{whois_server}"}
-    
-def get_whois_server(domain):
-    """Get WHOIS server from IANA root zone database."""
-    try:
-        response = requests.get(f'https://www.iana.org/whois?q={domain}')
-        if 'whois:' in response.text.lower():
-            for line in response.text.split('\n'):
-                if 'whois:' in line.lower():
-                    return line.split(':')[1].strip()
-    except:
-        pass
-    return None
+    is_available, availability_method, _continue = whois_is_available(domain)
+    if not _continue:
+        return {"available": is_available, "method": f"WHOIS:{availability_method}"}
 
-def check_dns_records(domain):
+def dns_is_available(domain):
     """Check if domain exists in DNS by looking for common record types."""
     # Check NS records first as they're required for valid domains
     for record_type in ['NS', 'A', 'AAAA', 'MX', 'CNAME']:
         try:
             dns.resolver.resolve(domain, record_type)
-            return True, record_type
+            return False, record_type, False
         except:
             continue
-    return False, None
+    return True, None, True
 
-def check_rdap_records(domain):
+def rdap_is_available(domain):
     try:
         bootstrap_url = "https://data.iana.org/rdap/dns.json"
         bootstrap_data = requests.get(bootstrap_url, timeout=5).json()
-        
         tld = domain.split('.')[-1]
-        rdap_base_url = None
-        
-        for service in bootstrap_data['services']:
-            if tld in service[0]:
-                rdap_base_url = service[1][0].strip('/')
-                break
-        
-        if rdap_base_url:
-            rdap_url = f"{rdap_base_url}/domain/{domain}"
-            response = requests.get(rdap_url, timeout=5)
-            return response.status_code, rdap_base_url
+        services: list[tuple[list[str], list[str]]] = bootstrap_data['services']
+        for [tlds, rdap_base_urls] in services:
+            if tld in tlds:
+                for rdap_base_url in rdap_base_urls:
+                    response = requests.get(
+                        f"{rdap_base_url.lstrip('/')}/domain/{domain}", timeout=5)
+                    if response.status_code == 404:
+                        return True, rdap_base_url, False
+                    elif response.status_code == 200:
+                        return False, rdap_base_url, False
     except:
         pass
-    return None, None
+    return False, None, True
 
-def no_whois_records(domain, whois_server) -> bool:
+def whois_is_available(domain) -> bool:
     try:
-        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-        sock.settimeout(5)
-        sock.connect((whois_server, 43))
-        sock.send(f"{domain}\r\n".encode())
-        response = sock.recv(4096).decode(errors='ignore')
-        sock.close()
-        
         available_patterns = [
             'no match',
             'not found',
@@ -115,11 +111,63 @@ def no_whois_records(domain, whois_server) -> bool:
             'status: free',
             'domain not found'
         ]
+        is_available_callback = lambda output: any(pattern in output for pattern in available_patterns)
+        is_available, availability_method = socket_whois_is_available(domain, is_available_callback)
+        if is_available:
+            return True, availability_method, False
+        is_available, availability_method = terminal_whois_is_available(domain, is_available_callback)
+        if is_available:
+            return True, availability_method, False
+    except:
+        pass
+    return False, None, True
+
+def socket_whois_is_available(domain, is_available_callback):
+    try:
+        whois_server = get_whois_server(domain)
+        whois_server = "whois.reg.ly"
+
+        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        sock.settimeout(5)
+        sock.connect((whois_server, 43))
+        sock.send(f"{domain}\r\n".encode())
+        response = sock.recv(4096).decode(errors='ignore')
+        sock.close()
         
         response_lower = response.lower()
-        for pattern in available_patterns:
-            if pattern in response_lower:
-                return True
+        return is_available_callback(response_lower), whois_server
+    except:
+        pass
+    return False, None
+
+def terminal_whois_is_available(domain, is_available_callback):
+    try:
+        # Check if OS is Linux
+        if platform.system().lower() == 'linux':
+            if which('whois') is not None:
+                # Run whois command with timeout
+                process = subprocess.Popen(
+                    ['whois', domain], 
+                    stdout=subprocess.PIPE, 
+                    stderr=subprocess.PIPE)
+                try:
+                    stdout, _ = process.communicate(timeout=60)
+                    output = stdout.decode('utf-8', errors='ignore').lower()
+                    return is_available_callback(output), "system whois"
+                except subprocess.TimeoutExpired:
+                    process.kill()
+    except:
+        pass
+    return False, None
+
+def get_whois_server(domain):
+    """Get WHOIS server from IANA root zone database."""
+    try:
+        response = requests.get(f'https://www.iana.org/whois?q={domain}')
+        if 'whois:' in response.text.lower():
+            for line in response.text.split('\n'):
+                if 'whois:' in line.lower():
+                    return line.split(':')[1].strip()
     except:
         pass
-    return False
+    return None

index.html

@@ -13,8 +13,13 @@
             <div class="col-md-6">
                 <div class="card">
                     <div class="card-body">
-                        <h3 class="text-center mb-4">Private Domain Checker - ToKnow.ai</h3>
-                        <form id="searchForm" class="mb-3">
+                        <h3 class="text-center">Private Domain Checker</h3>
+                        <p class="text-center text-body-secondary">
+                            <a href="https://toknow.ai" class="text-decoration-none text-reset">
+                                ToKnow.ai
+                            </a>
+                        </p>
+                        <form id="searchForm" class="mb-3 mt-4">
                             <div class="input-group">
                                 <input type="text" id="domain" class="form-control" placeholder="Enter domain name...">
                                 <button class="btn btn-primary" type="submit">Check</button>
@@ -24,6 +29,11 @@
                             <div class="spinner-border text-primary d-none" id="spinner"></div>
                             <div id="resultText"></div>
                         </div>
+                        <p class="text-center text-body-secondary mt-4">
+                            <a href="https://toknow.ai/about" class="text-decoration-none">
+                                Get help at ToKnow.ai
+                            </a>
+                        </p>
                     </div>
                 </div>
             </div>
@@ -43,19 +53,13 @@
             resultText.innerHTML = '';
 
             try {
-                const response = await fetch('/check', {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify({ domain })
-                });
-
+                const response = await fetch(`/check/${domain}`, { method: 'POST' });
                 const data = await response.json();
 
                 resultText.innerHTML = `
                 <div class="alert ${data.available ? 'alert-success' : 'alert-danger'} mt-3">
-                    <strong>${domain}</strong> is ${data.available ? 'available' : 'not available'}
+                    <strong>${data.domain ?? domain}</strong> is ${data.available ? 'available' : 'not available'}
                     ${data.method ? `<br>(checked via ${data.method})` : ''}
-                    ${data.error ? `<br>(error: ${data.error})` : ''}
                 </div>
             `;
             } catch (err) {