homematic-manager 3.0.0-beta.14 → 3.0.0-beta.16

package/dist/occulite.d.ts

@@ -42,6 +42,22 @@ export interface OcculiteAuthOptions {
     readonly onNotice?: (level: 'info' | 'warn' | 'error', message: string) => void;
 }
 export declare const OCCULITE_TIMEOUT_MS = 5000;
+/**
+ * B-94, D-65: the header openccu-lite's lighttpd gate sets on every request it lets through under
+ * `/addons/`, to the bare id of the session it found (from either session cookie or `?sid=`). The
+ * gate removes a copy the client sent first. A CCU has no gate and passes a client's header through,
+ * an older openccu-lite image does the same, and the backend's port is open to every process on the
+ * box - so the header is only a claim, and the box is asked about it like about any other session.
+ */
+export declare const OCCULITE_SESSION_HEADER = "x-occulite-session";
+export interface OcculiteCheckOptions {
+    /**
+     * The addon contract's validation (openccu-lite `docs/PORTING-PROMPT.md`): the session only
+     * counts when `GET /api/auth/v1/state` confirms it. The `?sid=` hand-over keeps the D-40 check,
+     * where that second answer only supplies the name.
+     */
+    readonly requireState?: boolean;
+}
 /** A session id as the shell hands it over, `@…@` and all, or `undefined` when it is not one. */
 export declare function parseSid(value: string | null | undefined): string | undefined;
 /** Checks a session id against the box that issued it. */
@@ -54,6 +70,6 @@ export declare class OcculiteAuthenticator {
      * that cannot be asked alike. A caller cannot tell them apart, and therefore cannot use this to
      * find out whether a session exists.
      */
-    check(rawSid: string | null | undefined): Promise<OcculiteSession | undefined>;
+    check(rawSid: string | null | undefined, options?: OcculiteCheckOptions): Promise<OcculiteSession | undefined>;
 }
 //# sourceMappingURL=occulite.d.ts.map

package/dist/occulite.js

@@ -24,6 +24,14 @@
  * that cannot read the metadata store is of no use to a device manager whatever else it can do.
  */
 export const OCCULITE_TIMEOUT_MS = 5000;
+/**
+ * B-94, D-65: the header openccu-lite's lighttpd gate sets on every request it lets through under
+ * `/addons/`, to the bare id of the session it found (from either session cookie or `?sid=`). The
+ * gate removes a copy the client sent first. A CCU has no gate and passes a client's header through,
+ * an older openccu-lite image does the same, and the backend's port is open to every process on the
+ * box - so the header is only a claim, and the box is asked about it like about any other session.
+ */
+export const OCCULITE_SESSION_HEADER = 'x-occulite-session';
 /** A session id as the shell hands it over, `@…@` and all, or `undefined` when it is not one. */
 export function parseSid(value) {
     const bare = (value ?? '').replace(/^@|@$/g, '').trim();
@@ -45,7 +53,7 @@ export class OcculiteAuthenticator {
      * that cannot be asked alike. A caller cannot tell them apart, and therefore cannot use this to
      * find out whether a session exists.
      */
-    async check(rawSid) {
+    async check(rawSid, options = {}) {
         const sid = parseSid(rawSid);
         if (sid === undefined) {
             return undefined;
@@ -68,6 +76,10 @@ export class OcculiteAuthenticator {
             return undefined;
         }
         const who = await this.#who(sid);
+        if (who === undefined && options.requireState === true) {
+            this.#options.onNotice?.('warn', 'the box did not confirm the session of the X-Occulite-Session header');
+            return undefined;
+        }
         return { sid, name: who?.name ?? 'openccu-lite', level: who?.level ?? 2 };
     }
     /**

package/dist/server.d.ts

@@ -26,6 +26,7 @@ import type { SessionInfo } from '@homematic-manager/core';
 import { ApiWebSocketServer, Backend, type BackendOptions } from '@homematic-manager/backend';
 import { DeviceImageService } from './images.js';
 import { type Logger, type LogLevel } from './log.js';
+import { type OcculiteCheckOptions } from './occulite.js';
 import { SessionStore } from './sessions.js';
 /** The port the CLI binds by default - 8090, next to nothing else a Homematic user runs. */
 export declare const DEFAULT_PORT = 8090;
@@ -33,6 +34,12 @@ export declare const DEFAULT_PORT = 8090;
 export declare const DEFAULT_HOST = "127.0.0.1";
 /** How long `close()` waits for `backend.stop()` before it gives up and exits anyway. */
 export declare const SHUTDOWN_TIMEOUT_MS = 5000;
+/**
+ * B-94, D-65: how long the box's answer about an `X-Occulite-Session` is believed without asking
+ * again. The addon contract says to cache it briefly, if at all; a minute covers the burst of
+ * assets and the socket of one page load.
+ */
+export declare const GATE_RECHECK_MS = 60000;
 /**
  * How often an idle API socket is pinged. Below lighttpd's `server.max-read-idle` /
  * `max-write-idle` default of 60 s, which is what would otherwise cut the proxied socket of the
@@ -63,7 +70,7 @@ export interface CredentialChecker {
 }
 /** D-40: what the `occulite` hand-over asks. `OcculiteAuthenticator` is the real one. */
 export interface SessionChecker {
-    check(sid: string | null | undefined): Promise<{
+    check(sid: string | null | undefined, options?: OcculiteCheckOptions): Promise<{
         name: string;
         level: number;
         sid: string;

package/dist/server.js

@@ -25,11 +25,11 @@ import fs from 'node:fs/promises';
 import http from 'node:http';
 import path from 'node:path';
 import { ApiWebSocketServer, Backend, RegaAuthenticator, } from '@homematic-manager/backend';
-import { applyCookieToken, applySessionToken, clearedSessionCookie, createToken, isLoopbackHost, readCookie, SESSION_COOKIE, sessionCookie, TOKEN_COOKIE, tokenCookie, } from './auth.js';
+import { applyCookieToken, applySessionToken, clearedSessionCookie, createToken, hasTokenQuery, isLoopbackHost, readCookie, SESSION_COOKIE, sessionCookie, TOKEN_COOKIE, tokenCookie, withTokenQuery, } from './auth.js';
 import { DeviceImageService, readIconMapFile } from './images.js';
 import { clientAddress, parseLoginForm, pickLanguage, readBody, renderLoginPage, } from './login.js';
 import { createLogger, silentLogger } from './log.js';
-import { OcculiteAuthenticator, parseSid } from './occulite.js';
+import { OCCULITE_SESSION_HEADER, OcculiteAuthenticator, parseSid } from './occulite.js';
 import { defaultDataDir, defaultMetadataDir, defaultUiDir, packageVersion } from './paths.js';
 import { proxyRequest, proxyUpgrade } from './proxy.js';
 import { RateLimiter, SessionStore } from './sessions.js';
@@ -40,6 +40,12 @@ export const DEFAULT_PORT = 8090;
 export const DEFAULT_HOST = '127.0.0.1';
 /** How long `close()` waits for `backend.stop()` before it gives up and exits anyway. */
 export const SHUTDOWN_TIMEOUT_MS = 5000;
+/**
+ * B-94, D-65: how long the box's answer about an `X-Occulite-Session` is believed without asking
+ * again. The addon contract says to cache it briefly, if at all; a minute covers the burst of
+ * assets and the socket of one page load.
+ */
+export const GATE_RECHECK_MS = 60_000;
 /**
  * How often an idle API socket is pinged. Below lighttpd's `server.max-read-idle` /
  * `max-write-idle` default of 60 s, which is what would otherwise cut the proxied socket of the
@@ -216,6 +222,9 @@ export async function createWebHost(options = {}) {
                 return;
             }
             session = sessions.get(readCookie(request.headers.cookie, SESSION_COOKIE));
+            // B-94, D-65: on openccu-lite the gate names the session it let through. It is checked
+            // with the box like the `?sid=` hand-over, and ignored when the box does not confirm it.
+            session = await sessionFromGate(request, session);
             if (session?.credential !== undefined) {
                 // D-40: writes to the box go out as the session of whoever is looking at the page
                 backend?.noteMetaSession(session.credential);
@@ -362,6 +371,74 @@ export async function createWebHost(options = {}) {
         });
         response.end();
     }
+    /**
+     * B-94, D-65: the sessions made from the gate's `X-Occulite-Session`, by the box's session id,
+     * with the time the box confirmed it. A request of the same page load that has no cookie of ours
+     * yet - an asset, the socket - finds its session here instead of asking the box again.
+     */
+    const gateSessions = new Map();
+    let lastGateWarning = 0;
+    /** The session id the gate put on a request; `undefined` outside `occulite` mode and for a malformed one. */
+    function gateSid(request) {
+        if (!boxSessions) {
+            return undefined;
+        }
+        const value = request.headers[OCCULITE_SESSION_HEADER];
+        // two copies are joined with a comma by Node, which no session id contains: refused
+        return parseSid(Array.isArray(value) ? value.join(', ') : value);
+    }
+    /** A session made from this box session and confirmed less than `GATE_RECHECK_MS` ago. */
+    function cachedGateSession(sid) {
+        const entry = gateSessions.get(sid);
+        if (!entry) {
+            return undefined;
+        }
+        const session = sessions?.get(entry.id);
+        if (!session || Date.now() - entry.checkedAt > GATE_RECHECK_MS) {
+            gateSessions.delete(sid);
+            return undefined;
+        }
+        return session;
+    }
+    /**
+     * B-94, D-65: the session of a request that came through openccu-lite's gate.
+     *
+     * The `?sid=` hand-over and the cookie stay as they are; this only adds a third way in, for a
+     * request that has neither - a bookmark, a reload after our session expired - or whose cookie
+     * belongs to another box session than the one the gate found. The header is a claim until the box
+     * confirms it (`GET /api/auth/v1/state`): a CCU and an older openccu-lite image pass a client's
+     * header through, and the backend's port is open to every process on the box.
+     */
+    async function sessionFromGate(request, current) {
+        const offered = gateSid(request);
+        if (!boxSessions || !sessions || offered === undefined || current?.credential === offered) {
+            return current;
+        }
+        const cached = cachedGateSession(offered);
+        if (cached) {
+            return cached;
+        }
+        const checked = await boxSessions.check(offered, { requireState: true });
+        if (!checked) {
+            // a header the box does not confirm counts as no header: the cookie, the token and the
+            // redirect to the box decide, as they did before there was a header
+            if (Date.now() - lastGateWarning > GATE_RECHECK_MS) {
+                lastGateWarning = Date.now();
+                log.warn(`login: openccu-lite did not confirm the X-Occulite-Session from ${clientAddress(request)}`);
+            }
+            return current;
+        }
+        const now = Date.now();
+        for (const [sid, entry] of gateSessions) {
+            if (now - entry.checkedAt > GATE_RECHECK_MS) {
+                gateSessions.delete(sid);
+            }
+        }
+        const session = sessions.create(checked.name, checked.level, checked.sid);
+        gateSessions.set(checked.sid, { id: session.id, checkedAt: now });
+        log.info(`login: ${checked.name} (level ${String(checked.level)}) through the openccu-lite gate`);
+        return session;
+    }
     /** The token cookie of task 13 - `settings.cgi`'s hand-over still opens every door. */
     function hasValidToken(request) {
         return token !== undefined && readCookie(request.headers.cookie, TOKEN_COOKIE) === token;
@@ -433,6 +510,14 @@ export async function createWebHost(options = {}) {
             // D-32: and a login session opens the same socket, in the same way
             if (sessions) {
                 applySessionToken(request, token, (id) => sessions.get(id) !== undefined);
+                // B-94: the socket of a page that came in through the gate, before our cookie is there
+                const gate = gateSid(request);
+                if (token !== undefined &&
+                    gate !== undefined &&
+                    !hasTokenQuery(request.url) &&
+                    cachedGateSession(gate)) {
+                    request.url = withTokenQuery(request.url, token);
+                }
             }
             api.handleUpgrade(request, socket, head);
             return;

package/node_modules/@homematic-manager/backend/dist/api/backend.js

@@ -14,7 +14,7 @@
  * main process with it, issue #127).
  */
 import path from 'node:path';
-import { RPC_METHOD_NAMES, RSSI_UNKNOWN, countsAsServiceMessage, isAcknowledgeable, maintenanceAddress, mergeMethodHelp, methodsFor, callbackPinOption, normaliseDescription, repairMisdecodedUtf8, } from '@homematic-manager/core';
+import { RPC_METHOD_NAMES, RSSI_UNKNOWN, countsAsServiceMessage, isAcknowledgeable, isKnownInterface, maintenanceAddress, mergeMethodHelp, methodsFor, callbackPinOption, normaliseDescription, repairMisdecodedUtf8, } from '@homematic-manager/core';
 import { CacheStore } from '../cache/store.js';
 import { ConfigStore } from '../config/store.js';
 import { LinkTemplateStore } from '../config/linkTemplates.js';
@@ -92,6 +92,20 @@ export class Backend {
      * table - and it is emptied whenever the connection is rebuilt.
      */
     #noServiceMessages = new Set();
+    /**
+     * B-26 (#158): interfaces whose last `getServiceMessages` failed for a reason that may pass - a
+     * timeout, a process that is restarting. The failure is logged when the interface lands in
+     * here and not again until a call succeeds; before, the five-minute poll logged it every round.
+     */
+    #serviceMessageFailures = new Set();
+    /**
+     * B-26 (#158): the `system.listMethods` answer of a user-defined interface, asked once and
+     * dropped when the interface subscribes again - a re-`init` may be a restarted, updated process.
+     * `undefined` inside means "no usable list", and the method is then tried once, as before.
+     */
+    #listedMethods = new Map();
+    /** B-26: interfaces that do not have `system.listMethods` itself; kept for the connection. */
+    #noListMethods = new Set();
     #idleTimer;
     /** Task 38: the saved callback values a pinned one replaces are logged by the first `start()` only. */
     #pinsReported = false;
@@ -482,6 +496,9 @@ export class Backend {
     async #connect() {
         const connection = this.#config.connection;
         this.#noServiceMessages.clear();
+        this.#serviceMessageFailures.clear();
+        this.#listedMethods.clear();
+        this.#noListMethods.clear();
         const manager = (this.#options.createInterfaceManager ?? ((options) => new InterfaceManager(options)))({
             connection,
             handler: this.#callbackHandler(),
@@ -664,6 +681,8 @@ export class Backend {
     }
     /** Fills the caches of an interface that has just subscribed. */
     async #onInterfaceConnected(interfaceName) {
+        // B-26: a (re-)`init` may be a restarted process, so its method list is asked again
+        this.#listedMethods.delete(interfaceName);
         try {
             await this.#refreshDevices(interfaceName);
         }
@@ -1157,23 +1176,69 @@ export class Backend {
      * Does it make sense to ask this interface for its service messages?
      *
      * The built-in answer comes from the core's table: hmipserver has no `getServiceMessages` (the
-     * HmIP sweep below reads the `:0` channels instead) and the group process behind
-     * `VirtualDevices` answers it with invalid XML-RPC. A user-defined interface is asked once and
-     * then remembered for this session - see {@link isMethodUnsupported}.
+     * HmIP sweep below reads the `:0` channels instead), the group process behind `VirtualDevices`
+     * answers it with invalid XML-RPC, and CUxD with a fault and a warning in the CCU's syslog
+     * (B-26, #158). A user-defined interface is judged by its own `system.listMethods` where that
+     * gives a list, and is otherwise asked once and then remembered for this session - see
+     * {@link isMethodUnsupported}.
      */
-    #hasServiceMessages(interfaceName) {
+    async #hasServiceMessages(interfaceName) {
         if (this.#noServiceMessages.has(interfaceName)) {
             return false;
         }
-        return this.#manager?.resolved(interfaceName)?.serviceMessages !== false;
+        if (this.#manager?.resolved(interfaceName)?.serviceMessages === false) {
+            return false;
+        }
+        // the table is measured for the built-in processes; asking rfd for its method list after
+        // every `init` would buy nothing
+        if (isKnownInterface(interfaceName)) {
+            return true;
+        }
+        const listed = await this.#methodList(interfaceName);
+        return listed === undefined || listed.has('getServiceMessages');
+    }
+    /**
+     * B-26 (#158): the methods a user-defined interface lists in `system.listMethods`, or
+     * `undefined` when it gave no usable list.
+     *
+     * Asked once and shared by concurrent callers; the answer is dropped when the interface
+     * subscribes again. A process that does not have `system.listMethods` either is remembered for
+     * the connection, so it is not asked after every re-`init`; any other failure is forgotten, and
+     * the next caller asks again.
+     */
+    #methodList(interfaceName) {
+        if (this.#noListMethods.has(interfaceName)) {
+            return Promise.resolve(undefined);
+        }
+        const cached = this.#listedMethods.get(interfaceName);
+        if (cached) {
+            return cached;
+        }
+        const pending = this.#read(interfaceName, 'system.listMethods', []).then((answer) => {
+            const names = asStrings(answer);
+            return names.length === 0 ? undefined : new Set(names);
+        }, (error) => {
+            if (isMethodUnsupported(error)) {
+                this.#noListMethods.add(interfaceName);
+            }
+            if (this.#listedMethods.get(interfaceName) === pending) {
+                this.#listedMethods.delete(interfaceName);
+            }
+            return undefined;
+        });
+        this.#listedMethods.set(interfaceName, pending);
+        return pending;
     }
     /** Reads the BidCos service messages of one interface into the store. */
     async #refreshServiceMessages(interfaceName) {
-        if (!this.#hasServiceMessages(interfaceName)) {
+        if (!(await this.#hasServiceMessages(interfaceName))) {
             return;
         }
         try {
             const answer = await this.#read(interfaceName, 'getServiceMessages', []);
+            if (this.#serviceMessageFailures.delete(interfaceName)) {
+                this.#notice('info', `${interfaceName}: getServiceMessages answers again`, interfaceName);
+            }
             if (!Array.isArray(answer)) {
                 return;
             }
@@ -1200,8 +1265,14 @@ export class Backend {
             // of it on hardware (task 17). Remembered, and never asked again this session.
             if (isMethodUnsupported(error)) {
                 this.#noServiceMessages.add(interfaceName);
+                this.#serviceMessageFailures.delete(interfaceName);
+                return;
+            }
+            // B-26 (#158): once per interface until a call succeeds again, not once per poll
+            if (this.#serviceMessageFailures.has(interfaceName)) {
                 return;
             }
+            this.#serviceMessageFailures.add(interfaceName);
             this.#notice('info', `${interfaceName}: getServiceMessages failed: ${errorMessage(error)}`, interfaceName);
         }
     }

package/node_modules/@homematic-manager/backend/dist/errors.d.ts

@@ -73,6 +73,18 @@ export declare function isMethodUnsupported(value: unknown): boolean;
  * the message text as well, because `connectionError()` composes its text before the cause is set.
  */
 export declare function isConnectionRefused(value: unknown): boolean;
+/**
+ * B-28: did the interface not answer - a timeout, or no route to its host?
+ *
+ * The counterpart of {@link isConnectionRefused}, and deliberately not the same state: a refused
+ * port means the process is not there, a call that times out means it is slow or its host is away
+ * for a moment. A CCU-Jack or a remote CUxD that does not answer for a minute must stay what it is,
+ * a configured interface that is not answering, and be tried again - not "not present".
+ *
+ * `RpcClient` rejects a call that runs past its timeout with a `kind: 'connection'` error whose text
+ * says "timed out", so the text is looked at as well as the codes along the `cause` chain.
+ */
+export declare function isNotAnswering(value: unknown): boolean;
 /**
  * Task 38: a callback server's bind failed because another process holds the port - hm2mqtt.js on
  * the same pair, or a second container on the host network. Looked for along the `cause` chain and

package/node_modules/@homematic-manager/backend/dist/errors.js

@@ -133,8 +133,10 @@ const UNSUPPORTED_METHOD_PATTERNS = [
     /unknown xml-rpc tag/i,
     // binrpc's own parser
     /malformed response/i,
-    // an interface that answers XML-RPC properly but has no handler for the method
-    /unknown method/i,
+    // an interface that answers XML-RPC properly but has no handler for the method. rfd words it
+    // `unknown method name`, CUxD `unknown.method name` - both with faultCode -1, which is also
+    // eq-3's "generic error", so the code alone says nothing (B-26, #158)
+    /unknown[ ._]method/i,
     /method not found/i,
 ];
 /** The standard XML-RPC fault code for a method the server does not have. */
@@ -182,6 +184,37 @@ export function isConnectionRefused(value) {
     }
     return /\bECONNREFUSED\b/.test(errorMessage(value));
 }
+/** The socket codes of a host that did not answer in time or cannot be reached at all. */
+const NOT_ANSWERING_CODES = new Set(['ETIMEDOUT', 'EHOSTUNREACH', 'ENETUNREACH', 'EHOSTDOWN']);
+/**
+ * B-28: did the interface not answer - a timeout, or no route to its host?
+ *
+ * The counterpart of {@link isConnectionRefused}, and deliberately not the same state: a refused
+ * port means the process is not there, a call that times out means it is slow or its host is away
+ * for a moment. A CCU-Jack or a remote CUxD that does not answer for a minute must stay what it is,
+ * a configured interface that is not answering, and be tried again - not "not present".
+ *
+ * `RpcClient` rejects a call that runs past its timeout with a `kind: 'connection'` error whose text
+ * says "timed out", so the text is looked at as well as the codes along the `cause` chain.
+ */
+export function isNotAnswering(value) {
+    if (isConnectionRefused(value)) {
+        return false;
+    }
+    let current = value;
+    for (let depth = 0; current !== undefined && current !== null && depth < 10; depth += 1) {
+        const candidate = current;
+        if (typeof candidate.code === 'string' && NOT_ANSWERING_CODES.has(candidate.code)) {
+            return true;
+        }
+        if (Array.isArray(candidate.errors) && candidate.errors.some((entry) => isNotAnswering(entry))) {
+            return true;
+        }
+        current = candidate.cause;
+    }
+    const text = errorMessage(value);
+    return /\btimed out\b/i.test(text) || /\b(ETIMEDOUT|EHOSTUNREACH|ENETUNREACH|EHOSTDOWN)\b/.test(text);
+}
 /**
  * Task 38: a callback server's bind failed because another process holds the port - hm2mqtt.js on
  * the same pair, or a second container on the host network. Looked for along the `cause` chain and

package/node_modules/@homematic-manager/backend/dist/interfaces/manager.d.ts

@@ -23,6 +23,7 @@ import type { CallbackPins, ConnectionConfig, InterfaceState, ResolvedInterface
 import { type InterfaceTarget } from '../config/defaults.js';
 import { RpcClient, type RpcCallRecord, type RpcClientOptions } from '../rpc/client.js';
 import { type CallbackHandler, type CallbackServerSet } from '../rpc/server.js';
+import { type PortProbe } from '../util/net.js';
 /** How often the watchdog looks at every interface. 2.x used the same 15 s. */
 export declare const WATCHDOG_INTERVAL_MS = 15000;
 /** Where an interface process on this very box calls back (#144). */
@@ -91,7 +92,7 @@ export interface InterfaceManagerOptions {
     /** Injected by the tests. */
     readonly createClient?: (options: RpcClientOptions) => RpcClient;
     readonly createCallbackServers?: (handler: CallbackHandler) => CallbackServerSet;
-    readonly probe?: (host: string, port: number) => Promise<boolean>;
+    readonly probe?: (host: string, port: number) => Promise<PortProbe>;
     /** Injected for the callback address; defaults to this machine's IPv4 addresses. */
     readonly localAddresses?: () => string[];
     /**
@@ -181,9 +182,16 @@ export declare class InterfaceManager {
      */
     stop(): Promise<void>;
     /**
-     * Probes the well-known ports of every built-in interface on the configured host, in the
-     * background. Nothing waits for this; the result is a hint for the configuration dialog and a
-     * notice for an interface that is configured but whose port is closed.
+     * Probes the well-known ports of every built-in interface on the configured host, and the port
+     * of every configured user-defined interface where it is configured, in the background. Nothing
+     * waits for this; the result is a hint for the configuration dialog and a mark for an interface
+     * that is configured and not connected.
+     *
+     * B-28: only a *refused* port makes an interface "not present". Until beta.15 a probe that timed
+     * out counted the same, and a user-defined interface - which the built-in probe never looks at -
+     * was marked absent whenever it was not connected at that moment: a slow CCU-Jack or a remote
+     * CUxD on a box that was still booting disappeared from the popup's healthy states until the next
+     * start. A port that does not answer marks the interface as not answering, and it stays what it is.
      */
     probeInterfaces(): Promise<string[]>;
 }

package/node_modules/@homematic-manager/backend/dist/interfaces/manager.js

@@ -20,11 +20,11 @@
  * the root of the "endless loading" issues #121, #126, #128 and #134.
  */
 import { INTERFACE_NAMES, callbackPinOption, interfaceDefinition, interfacePort, isKnownInterface, } from '@homematic-manager/core';
-import { configError, connectionError, errorMessage, isAddressInUse, isConnectionRefused } from '../errors.js';
+import { configError, connectionError, errorMessage, isAddressInUse, isConnectionRefused, isNotAnswering, } from '../errors.js';
 import { interfaceTargets } from '../config/defaults.js';
 import { RpcClient } from '../rpc/client.js';
 import { CallbackServers } from '../rpc/server.js';
-import { localIPv4Addresses, probePort, withTimeout } from '../util/net.js';
+import { localIPv4Addresses, probePortState, withTimeout } from '../util/net.js';
 /** How often the watchdog looks at every interface. 2.x used the same 15 s. */
 export const WATCHDOG_INTERVAL_MS = 15_000;
 /** Where an interface process on this very box calls back (#144). */
@@ -232,7 +232,13 @@ export class InterfaceManager {
             entry.lastEvent = 0;
             entry.failures = 0;
             entry.retryAt = 0;
-            this.#update(entry, { connected: false, error: undefined, idle: true, subscribing: false });
+            this.#update(entry, {
+                connected: false,
+                error: undefined,
+                idle: true,
+                subscribing: false,
+                unreachable: false,
+            });
         }
         this.#options.onStateChanged(this.states());
     }
@@ -281,7 +287,7 @@ export class InterfaceManager {
         }
         entry.lastEvent = this.#now();
         if (!entry.state.connected) {
-            this.#update(entry, { connected: true, error: undefined });
+            this.#update(entry, { connected: true, error: undefined, unreachable: false });
             this.#options.onStateChanged(this.states());
         }
     }
@@ -324,36 +330,61 @@ export class InterfaceManager {
         this.#options.onStateChanged([]);
     }
     /**
-     * Probes the well-known ports of every built-in interface on the configured host, in the
-     * background. Nothing waits for this; the result is a hint for the configuration dialog and a
-     * notice for an interface that is configured but whose port is closed.
+     * Probes the well-known ports of every built-in interface on the configured host, and the port
+     * of every configured user-defined interface where it is configured, in the background. Nothing
+     * waits for this; the result is a hint for the configuration dialog and a mark for an interface
+     * that is configured and not connected.
+     *
+     * B-28: only a *refused* port makes an interface "not present". Until beta.15 a probe that timed
+     * out counted the same, and a user-defined interface - which the built-in probe never looks at -
+     * was marked absent whenever it was not connected at that moment: a slow CCU-Jack or a remote
+     * CUxD on a box that was still booting disappeared from the popup's healthy states until the next
+     * start. A port that does not answer marks the interface as not answering, and it stays what it is.
      */
     async probeInterfaces() {
         const connection = this.#options.connection;
-        const probe = this.#options.probe ?? ((host, port) => probePort(host, port, { timeoutMs: 2000 }));
-        const found = [];
-        await Promise.all(INTERFACE_NAMES.map(async (name) => {
-            const definition = interfaceDefinition(name);
-            if (!definition) {
-                return;
+        const probe = this.#options.probe ?? ((host, port) => probePortState(host, port, { timeoutMs: 2000 }));
+        const results = new Map();
+        const extraProbes = connection.interfaces
+            .filter((name) => !isKnownInterface(name))
+            .map(async (name) => {
+            const entry = this.#interfaces.get(name);
+            if (entry) {
+                results.set(name, await probe(entry.state.host, entry.state.port));
             }
-            const port = interfacePort(definition, { tls: connection.tls });
-            if (await probe(connection.host, port)) {
-                found.push(name);
+        });
+        const builtInProbes = INTERFACE_NAMES.map(async (name) => {
+            const definition = interfaceDefinition(name);
+            if (definition) {
+                results.set(name, await probe(connection.host, interfacePort(definition, { tls: connection.tls })));
             }
-        }));
-        this.#detected = INTERFACE_NAMES.filter((name) => found.includes(name));
+        });
+        await Promise.all([...builtInProbes, ...extraProbes]);
+        this.#detected = INTERFACE_NAMES.filter((name) => results.get(name) === 'open');
         for (const name of connection.interfaces) {
-            // an interface whose `init` already refused says the same thing; one notice is enough
+            const result = results.get(name);
+            if (this.isConnected(name) || result === undefined || result === 'open') {
+                continue;
+            }
             const known = this.#interfaces.get(name);
-            if (isKnownInterface(name) &&
-                !this.#detected.includes(name) &&
-                !this.isConnected(name) &&
-                known?.state.absent !== true) {
-                this.#options.onNotice('warn', `${name}: the port is closed on ${connection.host}`, name);
+            const where = known === undefined ? connection.host : `${known.state.host}:${String(known.state.port)}`;
+            if (result === 'refused') {
+                // an interface whose `init` already refused says the same thing; one notice is enough
+                if (known?.state.absent !== true) {
+                    this.#options.onNotice('warn', `${name}: the port is closed on ${where}`, name);
+                }
+                if (known) {
+                    this.#update(known, { absent: true, unreachable: false });
+                }
             }
-            if (known && !this.#detected.includes(name) && !this.isConnected(name)) {
-                this.#update(known, { absent: true });
+            else {
+                // and one whose `init` timed out has said this already
+                if (known?.state.unreachable !== true) {
+                    this.#options.onNotice('warn', `${name}: ${where} does not answer - kept as configured and tried again`, name);
+                }
+                if (known) {
+                    this.#update(known, { absent: false, unreachable: true });
+                }
             }
         }
         this.#options.onStateChanged(this.states());
@@ -459,6 +490,7 @@ export class InterfaceManager {
             connected: false,
             error: failure.message,
             absent: false,
+            unreachable: false,
             subscribing: false,
             callbackUrl: undefined,
             callbackFailure: { port: failure.port, inUse: failure.inUse },
@@ -493,7 +525,13 @@ export class InterfaceManager {
             entry.retryAt = 0;
             // hmipserver re-sends every device on `init` (occu#45), so the grids are not complete
             // until the sweep below is through; the UI shows "subscribing" until then
-            this.#update(entry, { connected: true, error: undefined, absent: false, subscribing: true });
+            this.#update(entry, {
+                connected: true,
+                error: undefined,
+                absent: false,
+                unreachable: false,
+                subscribing: true,
+            });
             if (wasFailing) {
                 this.#options.onNotice('info', `${interfaceName}: answering again`, interfaceName);
             }
@@ -516,17 +554,19 @@ export class InterfaceManager {
      *
      * Whether the port refuses the connection decides both the wording and the `absent` flag the
      * indicator reads - "not present" is a different thing from "the CCU is unreachable", and only
-     * the first one is the normal state of BidCos-Wired on a CCU without a wired gateway.
+     * the first one is the normal state of BidCos-Wired on a CCU without a wired gateway. A timeout
+     * or a host without a route is the second one, `unreachable` (B-28).
      */
     #noteInitFailure(entry, error) {
         const message = errorMessage(error);
         const absent = isConnectionRefused(error);
+        const unreachable = !absent && isNotAnswering(error);
         const first = entry.failures === 0;
         entry.failures += 1;
         const base = this.#options.initBackoffMs ?? WATCHDOG_INTERVAL_MS;
         const wait = Math.min(base * 2 ** (entry.failures - 1), MAX_INIT_BACKOFF_MS);
         entry.retryAt = this.#now() + wait;
-        this.#update(entry, { connected: false, error: message, absent, subscribing: false });
+        this.#update(entry, { connected: false, error: message, absent, unreachable, subscribing: false });
         if (!first) {
             return;
         }
@@ -553,6 +593,7 @@ export class InterfaceManager {
             ...(entry.lastEvent > 0 ? { lastEvent: entry.lastEvent } : {}),
         };
         setFlag(state, 'absent', changes.absent);
+        setFlag(state, 'unreachable', changes.unreachable);
         setFlag(state, 'subscribing', changes.subscribing);
         setFlag(state, 'idle', changes.idle);
         if ('error' in changes) {