dominds 1.26.1 → 1.26.2

package/dist/cli/webui.js

@@ -164,17 +164,19 @@ async function main(args = process.argv.slice(2)) {
             host: started.urlHost,
             port: started.port,
         })}`);
+        let httpsEndpoint;
         if (started.httpsPort !== undefined && started.httpsUrlHost !== undefined) {
+            httpsEndpoint = { host: started.httpsUrlHost, port: started.httpsPort };
             const httpsBaseUrl = (0, auth_1.formatServerOrigin)({
                 scheme: 'https',
-                host: started.httpsUrlHost,
-                port: started.httpsPort,
+                host: httpsEndpoint.host,
+                port: httpsEndpoint.port,
             });
             log.info(`HTTPS WebUI ready: ${httpsBaseUrl}`);
             log.debug(`HTTPS WebSocket endpoint: ${formatWebSocketEndpoint({
                 scheme: 'wss',
-                host: started.httpsUrlHost,
-                port: started.httpsPort,
+                host: httpsEndpoint.host,
+                port: httpsEndpoint.port,
             })}`);
         }
         if (auth.kind === 'enabled') {
@@ -185,6 +187,14 @@ async function main(args = process.argv.slice(2)) {
                 authKey: auth.key,
             });
             log.info(`auto auth url (sensitive): ${autoAuthUrl}`);
+            if (httpsEndpoint !== undefined) {
+                log.info(`HTTPS auto auth url (sensitive): ${(0, auth_1.formatAutoAuthUrl)({
+                    scheme: 'https',
+                    host: httpsEndpoint.host,
+                    port: httpsEndpoint.port,
+                    authKey: auth.key,
+                })}`);
+            }
             if (shouldOpen) {
                 log.debug(`Opening browser: ${autoAuthUrl}`);
                 openInBrowser(autoAuthUrl);

package/dist/server/network-hosts.js

@@ -42,9 +42,10 @@ const dgram = __importStar(require("node:dgram"));
 const net = __importStar(require("node:net"));
 const os = __importStar(require("node:os"));
 const log_1 = require("../log");
-const OUTBOUND_PROBE_HOST = 'github.com';
-const OUTBOUND_PROBE_PORT = 443;
-const OUTBOUND_PROBE_TIMEOUT_MS = 800;
+const UDP_ROUTE_PROBE_TARGETS = {
+    ipv4: { host: '192.0.2.1', port: 443 },
+    ipv6: { host: '2001:db8::1', port: 443 },
+};
 const log = (0, log_1.createLogger)('network-hosts');
 function normalizeNetworkHost(host) {
     const trimmed = host.trim();
@@ -88,7 +89,7 @@ function resolveHttpUrlHostForBindHost(bindHost) {
 }
 async function resolveLanHttpsHostsForBindHost(bindHost) {
     const normalizedHost = normalizeNetworkHost(bindHost);
-    log.info('Resolving LAN HTTPS certificate hosts', undefined, {
+    log.debug('Resolving LAN HTTPS certificate hosts', undefined, {
         bindHost,
         normalizedHost,
     });
@@ -105,10 +106,10 @@ async function resolveLanHttpsHostsForBindHost(bindHost) {
         });
     }
     const accepted = isLanHttpsHost(normalizedHost);
-    log.info('Resolved explicit LAN HTTPS certificate host', undefined, {
+    log.info('Resolved LAN HTTPS certificate hosts', undefined, {
         bindHost,
         normalizedHost,
-        accepted,
+        acceptedHosts: accepted ? [normalizedHost] : [],
     });
     return accepted ? [normalizedHost] : [];
 }
@@ -118,17 +119,21 @@ async function resolveDefaultLanHttpsHosts() {
 async function resolveBindAllLanHttpsHosts(params) {
     const rawCandidates = [];
     for (const family of params.families) {
-        rawCandidates.push(...(await getUdpOutboundHosts(family)));
+        rawCandidates.push(...(await getUdpRouteLocalHosts(family)));
     }
     for (const family of params.families) {
         rawCandidates.push(...getNetworkInterfaceHosts(family));
     }
     const hostname = os.hostname();
-    log.info('LAN HTTPS host detection hostname candidate', undefined, {
+    const hostnameAccepted = isDetectedHostnameCandidate(hostname);
+    log.debug('LAN HTTPS host detection hostname candidate', undefined, {
         method: 'os.hostname',
         host: hostname,
+        acceptedCandidate: hostnameAccepted,
     });
-    rawCandidates.push(hostname);
+    if (hostnameAccepted) {
+        rawCandidates.push(hostname);
+    }
     const uniqueCandidates = uniqueHosts(rawCandidates);
     const acceptedHosts = [];
     const rejectedHosts = [];
@@ -140,7 +145,12 @@ async function resolveBindAllLanHttpsHosts(params) {
             rejectedHosts.push(host);
         }
     }
-    log.info('Resolved bind-all LAN HTTPS certificate hosts', undefined, {
+    log.info('Resolved LAN HTTPS certificate hosts', undefined, {
+        bindHost: params.bindHost,
+        families: params.families,
+        acceptedHosts,
+    });
+    log.debug('Resolved bind-all LAN HTTPS certificate host diagnostics', undefined, {
         bindHost: params.bindHost,
         families: params.families,
         rawCandidates,
@@ -150,18 +160,18 @@ async function resolveBindAllLanHttpsHosts(params) {
     });
     return acceptedHosts;
 }
-async function getUdpOutboundHosts(kind) {
-    const host = await getUdpOutboundHost(kind);
+async function getUdpRouteLocalHosts(kind) {
+    const host = await getUdpRouteLocalHost(kind);
     return host === null ? [] : [host];
 }
-async function getUdpOutboundHost(kind) {
+async function getUdpRouteLocalHost(kind) {
     return await new Promise((resolve) => {
-        log.info('LAN HTTPS host detection UDP probe start', undefined, {
-            method: 'udp_outbound_probe',
+        const target = UDP_ROUTE_PROBE_TARGETS[kind];
+        log.debug('LAN HTTPS host detection UDP route probe start', undefined, {
+            method: 'udp_route_local_address_probe',
             family: kind,
-            remoteHost: OUTBOUND_PROBE_HOST,
-            remotePort: OUTBOUND_PROBE_PORT,
-            timeoutMs: OUTBOUND_PROBE_TIMEOUT_MS,
+            targetHost: target.host,
+            targetPort: target.port,
         });
         const socket = dgram.createSocket(kind === 'ipv4' ? 'udp4' : 'udp6');
         let settled = false;
@@ -169,12 +179,11 @@ async function getUdpOutboundHost(kind) {
             if (settled)
                 return;
             settled = true;
-            clearTimeout(timeout);
             socket.removeAllListeners('error');
             socket.close();
             const normalizedHost = host === null ? null : normalizeNetworkHost(host);
-            log.info('LAN HTTPS host detection UDP probe finish', undefined, {
-                method: 'udp_outbound_probe',
+            log.debug('LAN HTTPS host detection UDP route probe finish', undefined, {
+                method: 'udp_route_local_address_probe',
                 family: kind,
                 reason,
                 host,
@@ -182,18 +191,14 @@ async function getUdpOutboundHost(kind) {
             });
             resolve(normalizedHost);
         };
-        const timeout = setTimeout(() => {
-            finish(null, 'timeout');
-        }, OUTBOUND_PROBE_TIMEOUT_MS);
-        timeout.unref();
         socket.once('error', (error) => {
-            log.info('LAN HTTPS host detection UDP probe error', error, {
-                method: 'udp_outbound_probe',
+            log.debug('LAN HTTPS host detection UDP route probe error', error, {
+                method: 'udp_route_local_address_probe',
                 family: kind,
             });
             finish(null, 'error');
         });
-        socket.connect(OUTBOUND_PROBE_PORT, OUTBOUND_PROBE_HOST, () => {
+        socket.connect(target.port, target.host, () => {
             const address = socket.address();
             if (typeof address === 'string') {
                 finish(null, 'non_ip_socket_address');
@@ -229,7 +234,7 @@ function getNetworkInterfaceHosts(kind) {
             }
         }
     }
-    log.info('LAN HTTPS host detection networkInterfaces result', undefined, {
+    log.debug('LAN HTTPS host detection networkInterfaces result', undefined, {
         method: 'os.networkInterfaces',
         family: kind,
         hosts,
@@ -237,6 +242,14 @@ function getNetworkInterfaceHosts(kind) {
     });
     return hosts;
 }
+function isDetectedHostnameCandidate(host) {
+    const normalizedHost = normalizeNetworkHost(host);
+    if (!isLanHttpsHost(normalizedHost))
+        return false;
+    if (net.isIP(normalizedHost) !== 0)
+        return true;
+    return normalizedHost.includes('.');
+}
 function uniqueHosts(rawHosts) {
     const hosts = [];
     const seen = new Set();

package/dist/server.js

@@ -121,16 +121,16 @@ async function startServer(opts = {}) {
     }
     const tls = certificateLookup.kind === 'found' && !strictPort ? certificateLookup.certificate : undefined;
     const urlHost = (0, network_hosts_1.resolveHttpUrlHostForBindHost)(host);
-    log.info(`Starting server in ${mode} mode on ${(0, auth_1.formatServerOrigin)({
+    log.debug(`Starting server in ${mode} mode on ${(0, auth_1.formatServerOrigin)({
         scheme: 'http',
         host: urlHost,
         port: preferredPort,
     })} (bind ${host}; ${strictPort ? 'strict port' : `auto port ${portAutoDirection}`}; working language: ${(0, work_language_1.getWorkLanguage)()} from ${source})`);
     if (certificateLookup.kind === 'found' && strictPort) {
-        log.info(`HTTPS certificate found but Dominds HTTPS is disabled for strict --port; assuming HTTPS, if needed, is handled by a front proxy (${certificateLookup.certificate.certPath})`);
+        log.debug(`HTTPS certificate found but Dominds HTTPS is disabled for strict --port; assuming HTTPS, if needed, is handled by a front proxy (${certificateLookup.certificate.certPath})`);
     }
     else if (tls !== undefined) {
-        log.info(`HTTPS certificate available: ${tls.certPath} (matched host ${tls.matchedHost})`);
+        log.debug(`HTTPS certificate available: ${tls.certPath} (matched host ${tls.matchedHost})`);
     }
     let startedCore = null;
     let boundPort = null;
@@ -208,7 +208,7 @@ async function startServer(opts = {}) {
             await startedCore.stop();
             throw new Error(`Failed to start WebUI HTTPS: no available adjacent port found from ${preferredHttpsPort}`);
         }
-        log.info(`HTTPS WebUI ready: ${(0, auth_1.formatServerOrigin)({
+        log.debug(`HTTPS WebUI ready: ${(0, auth_1.formatServerOrigin)({
             scheme: 'https',
             host: httpsUrlHost,
             port: httpsPort,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dominds",
-  "version": "1.26.1",
+  "version": "1.26.2",
   "description": "Dominds CLI and aggregation shell for the LongRun AI kernel/runtime packages.",
   "type": "commonjs",
   "publishConfig": {
@@ -53,9 +53,9 @@
     "ws": "^8.19.0",
     "yaml": "^2.8.2",
     "zod": "^4.3.6",
-    "@longrun-ai/kernel": "1.16.0",
     "@longrun-ai/codex-auth": "0.13.0",
-    "@longrun-ai/shell": "1.16.0"
+    "@longrun-ai/shell": "1.16.0",
+    "@longrun-ai/kernel": "1.16.0"
   },
   "devDependencies": {
     "@types/node": "^25.3.5",