bab4f210 · permissionBRICK/SillyTavern

 import util from 'node:util';
 import net from 'node:net';
 import dns from 'node:dns';
 +import { promises as dnsPromise } from 'node:dns'
 import process from 'node:process';
 import { fileURLToPath } from 'node:url';

+}
 async function canResolve(name, useIPv6 = true, useIPv4 = true) {
 -    return new Promise((resolve, reject) => {
 +    try {
 -        let v6Resolve
 +        let v6Resolved = false;
 -        let v4Resolve
 +        let v4Resolved = false;
         if (useIPv6) {
 -            dns.resolve6(name, (err) => {
 +            try {
 -                if (err) {
 +                await dnsPromise.resolve6(name);
 -                    v6Resolve = false
 +                v6Resolved = true;
                             } elsecatch (error) {
 -                    v6Resolve = true
 +                v6Resolved = false;
+                            }
 -            });
+-
 -        } else {
 -            v6Resolve = false
+        }
 +        // If we need to check IPv4 resolution
         if (useIPv4) {
 -            dns.resolve(name, (err) => {
 +            try {
 -                if (err) {
 +                await dnsPromise.resolve(name);
 -                    v4Resolve = false
 +                v4Resolved = true;
                             } elsecatch (error) {
 -                    v4Resolve = true
 +                v4Resolved = false;
+                            }
 -            });
+-
 -        } else {
 -            v4Resolve = false
+        }
 -        if (v6Resolve || v4Resolve) {
 +        console.log(v6Resolved, v4Resolved)
 -            resolve
 +        return v6Resolved || v4Resolved;
 -        } else {
++
 -            reject
 +    } catch (error) {
 -        }
 +        return false;
     });
+}
 async function getHasIP() {

 /**
  * Gets the hostname to use for autorun in the browser.
  * @returns promise({string} The hostname to use for autorun
  */
 async function getAutorunHostname(useIPv6, useIPv4) {
     if (autorunHostname === 'auto') {
 +        let localhostResolve = await canResolve('localhost', useIPv6, useIPv4)
++
         if (useIPv6 && useIPv4) {
             if (avoidLocalhost || !localhostResolve) return '[::1]';
             return 'localhost';
+        }

@@ -792,6 +788,7 @@ function getAutorunHostname(useIPv6, useIPv4) {
792	788	}
793	789	}
794	790
	791	+
795	792	return autorunHostname;
796	793	}
797	794

 const postSetupTasks = async function (v6Failed, v4Failed, useIPv6, useIPv4) {
     const autorunUrl = new URL(
         (cliArguments.ssl ? 'https://' : 'http://') +
         (await getAutorunHostname(useIPv6, useIPv4)) +
         (':') +
         ((autorunPortOverride >= 0) ? autorunPortOverride : server_port),
     );

         process.exit(1);
+    }
++
     const [v6Failed, v4Failed] = await startHTTPorHTTPS(useIPv6, useIPv4);
     handleServerListenFail(v6Failed, v4Failed, useIPv6, useIPv4);

added dns checking