signalk-container-helper 0.6.1 → 0.8.0

package/README.md

@@ -157,6 +157,28 @@ field from _its own_ app object — so you get
 | A private writable area in the SK data tree | `signalkDataMount` (signalk-container's)         |
 | The whole SK config root                    | `signalkConfigRootMount` (incl. `security.json`) |
 | **Your own plugin's data dir**              | **`resolveMount()`** + a `volumes` entry         |
+| **Is there a GPU / device on the host?**    | **`probeHostDevice()`**                          |
+
+`probeHostDevice(manager, path)` answers whether the **host** has a device,
+which a plugin cannot determine itself — `stat("/dev/dri")` describes the
+plugin's own filesystem, and that is the Signal K container whenever Signal K
+is containerized:
+
+```ts
+import { probeHostDevice } from "signalk-container-helper";
+
+const gpu = await probeHostDevice(manager, "/dev/dri");
+if (gpu?.exists) {
+  config.devices = ["/dev/dri"];
+  config.groupAdd = gpu.groups; // names, resolved on the host
+}
+```
+
+`null` means **unknown** (no runtime, or the host could not be read) and is
+deliberately distinct from `{ exists: false }` — assume no device, but do not
+report it as absent. Throws `ContainerHelperError('unsupported-manager')` on
+signalk-container older than 1.30.0, so catch it if you would rather degrade
+than fail. Works on both Docker and rootless podman.
 
 `resolveMount` translates any absolute host path into a mount the container
 runtime can actually bind, on bare-metal and containerized Signal K alike:
@@ -272,6 +294,158 @@ Why not `manager.getState()` for health? signalk-container namespace-prefixes th
 containers it manages (`sk-<name>`); externally-managed peers don't carry the prefix,
 so the manager can't see them — and "running" isn't "healthy" anyway.
 
+## Managed or self-hosted
+
+Some operators would rather run the service themselves — on a NAS, another Pi, or
+a box that is already doing the job — and point the plugin at it. That is a
+config switch (`managedContainer`) plus an address, and every plugin that offers
+it had written its own.
+
+**Scope, precisely:** this means the _service_ runs elsewhere. It does **not**
+mean a container _engine_ elsewhere — signalk-container talks to local unix
+sockets only and rejects a `tcp://` endpoint, so there is no remote-engine mode
+to opt into.
+
+```ts
+import {
+  resolveEndpoint,
+  waitForEndpointReady,
+  isManagedMode,
+} from "signalk-container-helper";
+
+const endpoint = await resolveEndpoint({
+  managed: settings.managedContainer, // pass the RAW config value
+  externalUrl: settings.externalUrl,
+  container, // a started ManagedContainer; managed mode only
+  port: 3020,
+  productName: "signalk-tailscale-server",
+});
+
+await waitForEndpointReady(endpoint, { path: "/api/health" });
+const client = new ShimClient(endpoint.baseUrl);
+```
+
+`endpoint.baseUrl` is scheme-ful with no trailing slash in both modes, so the
+transport half of your plugin stops caring which mode it is in. `endpoint.mode`
+is there for the parts that legitimately differ.
+
+### Pass the raw config value
+
+`managed` is `boolean | undefined`, and **`undefined` means managed**. Signal K
+calls `plugin.start()` with `{}` when a plugin is enabled without its form ever
+being saved, so `Boolean(config.managedContainer)` would flip exactly those
+installs into self-hosted mode with an empty URL — a plugin that used to work
+now errors on enable. Use `isManagedMode(...)` anywhere you need the mode
+question on its own (route guards, status fields).
+
+### Readiness retries are opt-in
+
+`waitForEndpointReady` makes **one** attempt unless you pass `retry`. The
+reference plugins genuinely differ here — one retries forever because an
+unattended boat has to heal itself, another reports once and waits for the
+operator — so neither behaviour is imposed:
+
+```ts
+await waitForEndpointReady(endpoint, {
+  path: "/api/health",
+  signal,
+  retry: {
+    minDelayMs: 15_000,
+    onAttemptFailed: (err, next) =>
+      app.setPluginError(
+        `${endpoint.baseUrl} unreachable: ${errMsg(err)} — retrying in ${Math.round(next / 1000)}s`,
+      ),
+  },
+});
+```
+
+### The config fields
+
+`managedModeSchema` emits the two form fields as **plain JSON Schema**. It has to
+be plain: consumers are split between `typebox` 1.x and `@sinclair/typebox` 0.34,
+which are mutually incompatible, and this library depends on neither.
+
+Splice each fragment with `Type.Unsafe`. The call is written identically in both
+packages:
+
+```ts
+import { Type, type Static } from "@sinclair/typebox"; // or "typebox"
+import { managedModeSchema } from "signalk-container-helper/schema";
+
+const MODE = managedModeSchema({
+  productName: "signalk-tailscale-server",
+  image: "ghcr.io/dirkwa/signalk-tailscale-server",
+  exampleUrl: "http://192.168.1.50:3020",
+});
+
+export const ConfigSchema = Type.Object({
+  managedContainer: Type.Unsafe<boolean>(MODE.managedContainer),
+  externalUrl: Type.Unsafe<string>(MODE.externalUrl),
+  // …your own fields
+});
+
+export const SCHEMA_DEFAULTS: Config = {
+  ...MODE.defaults, // { managedContainer: true, externalUrl: "" }
+  // …your own defaults
+};
+```
+
+`Type.Unsafe` is not optional. A bare fragment spread straight into
+`Type.Object({...})` compiles under `typebox` 1.x and **fails** under
+`@sinclair/typebox` 0.34 (`missing the following properties from type
+'TSchema': params, static, [Kind]`).
+
+Two things to know about it. It **asserts** the static type rather than deriving
+it, so keep the type argument and the fragment's `type` in step — nothing checks
+that for you. And `Type.Unsafe` emits the same keys and values as
+`Type.Boolean`/`Type.String` but in a different **order** (`type` first rather
+than last); that is meaningless to JSON Schema and to the Admin UI's form
+renderer, so compare with sorted keys if you assert on the emitted schema while
+migrating.
+
+#### Why not just move every plugin to `typebox` 1.x?
+
+Because it would not remove the split. `@signalk/server-api` depends on
+`@sinclair/typebox` 0.34 itself, so the scoped package sits in every consumer's
+dependency tree regardless of which one the plugin picks for its own schema —
+`signalk-questdb` already resolves **both** today. Migrating a plugin adds a
+second TypeBox beside the first rather than replacing it.
+
+Migrating is still reasonable on its own merits: `@sinclair/typebox` is frozen
+at 0.34.52 (TypeBox 1.x was republished under the unscoped `typebox` name
+instead of taking a major bump), so plugins on the scoped package are on a line
+that receives no further fixes. For the constructs these plugins actually use —
+`Object`, `String`, `Boolean`, `Number`, `Literal`, `Union`, `Array` — the two
+versions emit semantically identical JSON Schema (verified; only key order
+differs), and `Type`/`Static` import the same way, so it is a per-plugin import
+swap rather than a port.
+
+What it is not is a prerequisite for this API. Emitting plain JSON Schema keeps
+this module out of the question entirely, and works before, during and after any
+such migration.
+
+Spreading `MODE.defaults` matters because Signal K uses a schema `default` only
+to seed the _form_, never the config object a plugin receives — which is why
+every consumer hand-writes a `SCHEMA_DEFAULTS` beside its schema, and why those
+two drift.
+
+### `managedContainer` means something else in two plugins
+
+`signalk-doctor` and `signalk-updater` also have a `managedContainer` option, but
+it defaults to **false** and means _"a systemd Quadlet owns this local
+container"_ — not _"the service is on another host"_. It is a name collision,
+not a variant of this feature: those plugins have no remote endpoint, and
+`AdoptedContainer` is what already models them. Do not wire them to
+`resolveEndpoint`.
+
+### A self-hosted upstream has to be resolved, not assumed
+
+A consumer that hardcodes a container DNS name (`sk-<name>:<port>`) to reach a
+peer will break when that peer is self-hosted — and, in fact, already breaks on
+a bare-metal or shared-netns host, since signalk-container picks between
+loopback and container DNS depending on the topology. Resolve peer addresses
+rather than assuming one.
+
 ## Config-panel UI (`signalk-container-helper/ui`)
 
 The reference plugins also share a hand-copied React config panel: a container
@@ -498,24 +672,29 @@ Adopt these even where you don't use the components:
 
 ## API overview
 
-| Export                          | Purpose                                                                                                                                                                                                                                                                                  |
-| ------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `ManagedContainer`              | Full lifecycle: `start`, `stop`, `applyUpdate`, `checkForUpdate`, `getState`, `getInfo`, `resolveAddress`, `getLogs`, `registerUpdateRoutes`                                                                                                                                             |
-| `AdoptedContainer`              | Update registration + checks for externally-managed containers                                                                                                                                                                                                                           |
-| `getContainerManager()`         | Read the `globalThis.__signalk_containerManager` global                                                                                                                                                                                                                                  |
-| `waitForContainerManager(opts)` | Two-phase wait (manager present → runtime settled); returns `{ manager, runtime }` so the two failure modes get distinct messages                                                                                                                                                        |
-| `resolveMount(manager, opts)`   | Translate an absolute host path into a mountable `{ source, containerPath, subPath }` — how you mount **your own** plugin's data dir (see [Mounting your plugin's own data directory](#mounting-your-plugins-own-data-directory))                                                        |
-| `waitForHttpReady(url, opts)`   | Poll until 2xx or deadline (throws)                                                                                                                                                                                                                                                      |
-| `retryForever(fn, opts)`        | Retry until success — 15s doubling to a 120s ceiling, no attempt cap. `ManagedContainer` takes it as `readinessRetry`; exported standalone for work this library does not manage                                                                                                         |
-| `anySignal(signals)`            | Compose several `AbortSignal`s into one that aborts when any does (`undefined` when none are given)                                                                                                                                                                                      |
-| `probeHttpHealth(url, opts)`    | Retrying liveness probe with slow-response detection (never throws)                                                                                                                                                                                                                      |
-| `fetchWithTimeout(url, opts)`   | `fetch` with an `AbortController` timeout                                                                                                                                                                                                                                                |
-| `throwIfAborted(signal)`        | Throw `ContainerHelperError` `cancelled` if the signal has fired — the check the lifecycle methods run between steps                                                                                                                                                                     |
-| `startSafely(app, fn)`          | Sync wrapper for async plugin startup — Signal K does not await `start()`                                                                                                                                                                                                                |
-| `isValidImageTag(tag)`          | Tag guard (`IMAGE_TAG_PATTERN`)                                                                                                                                                                                                                                                          |
-| `errMsg(err)`                   | Normalize unknown errors to strings                                                                                                                                                                                                                                                      |
-| `ContainerHelperError`          | Typed error with `code` and `reported`                                                                                                                                                                                                                                                   |
-| Types                           | Local mirror of signalk-container's public API — `ContainerManagerApi`, `ContainerConfig`, `EnsureRunningOptions`, `UpdateServiceApi`, … — verified at build time against `signalk-container/types` (≥ 1.23.2) so it never silently drifts. Feature-detected members stay optional here. |
+| Export                           | Purpose                                                                                                                                                                                                                                                                                  |
+| -------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `ManagedContainer`               | Full lifecycle: `start`, `stop`, `applyUpdate`, `checkForUpdate`, `getState`, `getInfo`, `resolveAddress`, `getLogs`, `registerUpdateRoutes`                                                                                                                                             |
+| `AdoptedContainer`               | Update registration + checks for externally-managed containers                                                                                                                                                                                                                           |
+| `getContainerManager()`          | Read the `globalThis.__signalk_containerManager` global                                                                                                                                                                                                                                  |
+| `waitForContainerManager(opts)`  | Two-phase wait (manager present → runtime settled); returns `{ manager, runtime }` so the two failure modes get distinct messages                                                                                                                                                        |
+| `resolveMount(manager, opts)`    | Translate an absolute host path into a mountable `{ source, containerPath, subPath }` — how you mount **your own** plugin's data dir (see [Mounting your plugin's own data directory](#mounting-your-plugins-own-data-directory))                                                        |
+| `resolveEndpoint(opts)`          | Resolve the base URL for a managed container or a self-hosted service — pass the RAW `managedContainer` value (`undefined` means managed)                                                                                                                                                |
+| `waitForEndpointReady(ep, opts)` | Wait until a resolved endpoint answers 2xx. One attempt unless `retry` is given                                                                                                                                                                                                          |
+| `isManagedMode(value)`           | The `!== false` rule, named — for route guards and status fields                                                                                                                                                                                                                         |
+| `normalizeExternalUrl(raw)`      | Normalise operator-typed input into a base URL (scheme defaulted, trailing slash stripped, path discarded); `null` when unusable                                                                                                                                                         |
+| `managedModeSchema(opts)`        | The two config fields as plain JSON Schema + matching defaults (`signalk-container-helper/schema`)                                                                                                                                                                                       |
+| `waitForHttpReady(url, opts)`    | Poll until 2xx or deadline (throws)                                                                                                                                                                                                                                                      |
+| `retryForever(fn, opts)`         | Retry until success — 15s doubling to a 120s ceiling, no attempt cap. `ManagedContainer` takes it as `readinessRetry`; exported standalone for work this library does not manage                                                                                                         |
+| `anySignal(signals)`             | Compose several `AbortSignal`s into one that aborts when any does (`undefined` when none are given)                                                                                                                                                                                      |
+| `probeHttpHealth(url, opts)`     | Retrying liveness probe with slow-response detection (never throws)                                                                                                                                                                                                                      |
+| `fetchWithTimeout(url, opts)`    | `fetch` with an `AbortController` timeout                                                                                                                                                                                                                                                |
+| `throwIfAborted(signal)`         | Throw `ContainerHelperError` `cancelled` if the signal has fired — the check the lifecycle methods run between steps                                                                                                                                                                     |
+| `startSafely(app, fn)`           | Sync wrapper for async plugin startup — Signal K does not await `start()`                                                                                                                                                                                                                |
+| `isValidImageTag(tag)`           | Tag guard (`IMAGE_TAG_PATTERN`)                                                                                                                                                                                                                                                          |
+| `errMsg(err)`                    | Normalize unknown errors to strings                                                                                                                                                                                                                                                      |
+| `ContainerHelperError`           | Typed error with `code` and `reported`                                                                                                                                                                                                                                                   |
+| Types                            | Local mirror of signalk-container's public API — `ContainerManagerApi`, `ContainerConfig`, `EnsureRunningOptions`, `UpdateServiceApi`, … — verified at build time against `signalk-container/types` (≥ 1.23.2) so it never silently drifts. Feature-detected members stay optional here. |
 
 ### Error codes
 

package/dist/endpoint.d.ts

@@ -0,0 +1,93 @@
+import type { ManagedContainer } from "./managed-container.js";
+import type { FetchLike } from "./http.js";
+import { type RetryForeverOptions } from "./retry.js";
+export type EndpointMode = "managed" | "external";
+export interface ResolvedEndpoint {
+    mode: EndpointMode;
+    /** Scheme-ful base with no trailing slash — append absolute paths to it. */
+    baseUrl: string;
+    /**
+     * `host:port` — as the container manager reports it in managed mode, or as
+     * the operator's URL resolved to in self-hosted mode. A bare `host` when no
+     * port was given and none was defaulted. Never null in practice today; the
+     * type keeps the door open for a manager that cannot answer.
+     */
+    address: string | null;
+    /** The container, in managed mode only — null when self-hosted. */
+    container: ManagedContainer | null;
+}
+export interface ResolveEndpointOptions {
+    /**
+     * The raw config value. `undefined` MUST mean managed: Signal K calls
+     * `start()` with `{}` when a plugin is enabled without ever saving its form,
+     * and treating that as self-hosted would break every such install.
+     */
+    managed: boolean | undefined;
+    /** Raw operator input; normalised internally. Self-hosted mode only. */
+    externalUrl?: string;
+    /** Required in managed mode. Pass one that has already been started. */
+    container?: ManagedContainer;
+    /** Container port to resolve in managed mode. */
+    port?: number;
+    /** Product noun for error copy, e.g. "backup-server". */
+    productName: string;
+    /** Config key named in the empty-URL error. Default "externalUrl". */
+    urlFieldName?: string;
+    /** Port assumed when the external URL carries none. */
+    defaultPort?: number;
+}
+/**
+ * Whether the plugin owns its container's lifecycle.
+ *
+ * `undefined` means managed — Signal K hands `plugin.start()` an empty object
+ * when a plugin is enabled without its form ever being saved, so a plain
+ * `Boolean(managed)` would silently flip those installs into self-hosted mode
+ * with an empty URL: a plugin that used to just work now errors on enable.
+ *
+ * Exported because most call sites are route handlers and status fields that
+ * only need the mode question, not a resolved endpoint. Naming the rule makes
+ * it greppable and keeps the UI and the runtime from drifting apart.
+ */
+export declare function isManagedMode(managed: boolean | undefined): boolean;
+/**
+ * Resolve the base URL for whichever mode the config selects.
+ *
+ * Throws `ContainerHelperError` rather than returning a failure union: every
+ * consumer's existing branch is `setPluginError(...); return`, and throwing
+ * lets `startSafely` do that uniformly. `reported` is left false so the
+ * message — which matches the copy the plugins already show — is surfaced.
+ *
+ * Readiness is NOT waited for here; that is `waitForEndpointReady`, so the
+ * retry policy stays a caller decision.
+ */
+export declare function resolveEndpoint(options: ResolveEndpointOptions): Promise<ResolvedEndpoint>;
+export interface EndpointReadyOptions {
+    /** Probe path appended to the base URL. Default "/". */
+    path?: string;
+    /** Deadline for one readiness attempt. Default 15_000. */
+    maxMs?: number;
+    /** Delay between polls within an attempt. */
+    intervalMs?: number;
+    /** Per-request timeout. */
+    requestTimeoutMs?: number;
+    signal?: AbortSignal;
+    fetchImpl?: FetchLike;
+    /**
+     * When present, wrap the readiness wait in `retryForever` with these
+     * options. ABSENT MEANS ONE ATTEMPT, then throw.
+     *
+     * Not defaulted on, and that is deliberate: the reference plugins genuinely
+     * differ here — one retries forever because an unattended boat must heal
+     * itself, another reports the error once and waits for the operator. Baking
+     * either in would change the other's behaviour under cover of a refactor.
+     */
+    retry?: RetryForeverOptions;
+}
+/**
+ * Wait until the endpoint answers 2xx. Same call in both modes — the mode
+ * difference is already spent by the time there is a base URL.
+ */
+export declare function waitForEndpointReady(endpoint: ResolvedEndpoint, options?: EndpointReadyOptions): Promise<void>;
+/** Convenience for status fields and route guards. */
+export declare function describeEndpoint(endpoint: ResolvedEndpoint): string;
+//# sourceMappingURL=endpoint.d.ts.map

package/dist/endpoint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"endpoint.d.ts","sourceRoot":"","sources":["../src/endpoint.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAE3C,OAAO,EAAgB,KAAK,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAIpE,MAAM,MAAM,YAAY,GAAG,SAAS,GAAG,UAAU,CAAC;AAElD,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,YAAY,CAAC;IACnB,4EAA4E;IAC5E,OAAO,EAAE,MAAM,CAAC;IAChB;;;;;OAKG;IACH,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,mEAAmE;IACnE,SAAS,EAAE,gBAAgB,GAAG,IAAI,CAAC;CACpC;AAED,MAAM,WAAW,sBAAsB;IACrC;;;;OAIG;IACH,OAAO,EAAE,OAAO,GAAG,SAAS,CAAC;IAC7B,wEAAwE;IACxE,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,wEAAwE;IACxE,SAAS,CAAC,EAAE,gBAAgB,CAAC;IAC7B,iDAAiD;IACjD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,yDAAyD;IACzD,WAAW,EAAE,MAAM,CAAC;IACpB,sEAAsE;IACtE,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,uDAAuD;IACvD,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,OAAO,GAAG,SAAS,GAAG,OAAO,CAEnE;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,eAAe,CACnC,OAAO,EAAE,sBAAsB,GAC9B,OAAO,CAAC,gBAAgB,CAAC,CAmE3B;AAED,MAAM,WAAW,oBAAoB;IACnC,wDAAwD;IACxD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,0DAA0D;IAC1D,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,6CAA6C;IAC7C,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,2BAA2B;IAC3B,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,SAAS,CAAC,EAAE,SAAS,CAAC;IACtB;;;;;;;;OAQG;IACH,KAAK,CAAC,EAAE,mBAAmB,CAAC;CAC7B;AAED;;;GAGG;AACH,wBAAsB,oBAAoB,CACxC,QAAQ,EAAE,gBAAgB,EAC1B,OAAO,GAAE,oBAAyB,GACjC,OAAO,CAAC,IAAI,CAAC,CAiBf;AAED,sDAAsD;AACtD,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,gBAAgB,GAAG,MAAM,CAInE"}

package/dist/endpoint.js

@@ -0,0 +1,109 @@
+// The managed/self-hosted seam.
+//
+// A container-backed plugin reaches its service in one of two ways: through a
+// container signalk-container manages for it, or over the network at an address
+// the operator supplied ("self-hosted"). The transport half of those two is
+// identical — a base URL in, an HTTP client out — but every consumer currently
+// re-derives the mode branch, the empty-URL guard and the readiness wait.
+//
+// Scope note: "self-hosted" means a SERVICE on another host, never a container
+// ENGINE on another host. signalk-container talks to local unix sockets only
+// and throws on a tcp:// endpoint, so there is no remote-engine mode to model.
+import { waitForHttpReady } from "./http.js";
+import { retryForever } from "./retry.js";
+import { ContainerHelperError } from "./util.js";
+import { normalizeExternalUrl } from "./url.js";
+/**
+ * Whether the plugin owns its container's lifecycle.
+ *
+ * `undefined` means managed — Signal K hands `plugin.start()` an empty object
+ * when a plugin is enabled without its form ever being saved, so a plain
+ * `Boolean(managed)` would silently flip those installs into self-hosted mode
+ * with an empty URL: a plugin that used to just work now errors on enable.
+ *
+ * Exported because most call sites are route handlers and status fields that
+ * only need the mode question, not a resolved endpoint. Naming the rule makes
+ * it greppable and keeps the UI and the runtime from drifting apart.
+ */
+export function isManagedMode(managed) {
+    return managed !== false;
+}
+/**
+ * Resolve the base URL for whichever mode the config selects.
+ *
+ * Throws `ContainerHelperError` rather than returning a failure union: every
+ * consumer's existing branch is `setPluginError(...); return`, and throwing
+ * lets `startSafely` do that uniformly. `reported` is left false so the
+ * message — which matches the copy the plugins already show — is surfaced.
+ *
+ * Readiness is NOT waited for here; that is `waitForEndpointReady`, so the
+ * retry policy stays a caller decision.
+ */
+export async function resolveEndpoint(options) {
+    const { managed, externalUrl, container, port, productName, urlFieldName = "externalUrl", defaultPort, } = options;
+    if (!isManagedMode(managed)) {
+        const normalized = normalizeExternalUrl(externalUrl, { defaultPort });
+        if (!normalized) {
+            // The empty and malformed cases get different copy: one is "you haven't
+            // finished configuring", the other "what you typed cannot work".
+            const typed = typeof externalUrl === "string" ? externalUrl.trim() : "";
+            throw typed
+                ? new ContainerHelperError("external-url-invalid", `${productName}: ${urlFieldName} is not a valid http(s) URL: "${typed}". ` +
+                    `Expected something like http://192.168.1.50:3010.`)
+                : new ContainerHelperError("external-url-missing", `managedContainer is disabled but ${urlFieldName} is empty. ` +
+                    `Set ${urlFieldName} in plugin config.`);
+        }
+        return {
+            mode: "external",
+            baseUrl: normalized.baseUrl,
+            address: normalized.address,
+            container: null,
+        };
+    }
+    if (!container) {
+        throw new ContainerHelperError("invalid-option", `${productName}: resolveEndpoint requires a ManagedContainer in managed mode.`);
+    }
+    if (typeof port !== "number") {
+        throw new ContainerHelperError("invalid-option", `${productName}: resolveEndpoint requires a port in managed mode.`);
+    }
+    // resolveAddress never throws — it already absorbs the case where
+    // resolveContainerAddress rejects because ensureRunning has not run yet.
+    const address = await container.resolveAddress(port);
+    if (!address) {
+        throw new ContainerHelperError("address-unresolved", `Could not resolve address for ${productName} port ${port}. ` +
+            `Declare the port in signalkAccessiblePorts.`);
+    }
+    return {
+        mode: "managed",
+        baseUrl: `http://${address}`,
+        address,
+        container,
+    };
+}
+/**
+ * Wait until the endpoint answers 2xx. Same call in both modes — the mode
+ * difference is already spent by the time there is a base URL.
+ */
+export async function waitForEndpointReady(endpoint, options = {}) {
+    const { path = "/", retry, ...wait } = options;
+    const url = `${endpoint.baseUrl}${path.startsWith("/") ? path : `/${path}`}`;
+    const attempt = () => waitForHttpReady(url, {
+        maxMs: wait.maxMs ?? 15_000,
+        intervalMs: wait.intervalMs,
+        requestTimeoutMs: wait.requestTimeoutMs,
+        fetchImpl: wait.fetchImpl,
+        signal: wait.signal,
+    });
+    if (!retry) {
+        await attempt();
+        return;
+    }
+    await retryForever(attempt, retry);
+}
+/** Convenience for status fields and route guards. */
+export function describeEndpoint(endpoint) {
+    return endpoint.mode === "managed"
+        ? `managed container at ${endpoint.baseUrl}`
+        : `external service at ${endpoint.baseUrl}`;
+}
+//# sourceMappingURL=endpoint.js.map

package/dist/endpoint.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"endpoint.js","sourceRoot":"","sources":["../src/endpoint.ts"],"names":[],"mappings":"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"}

package/dist/host-device.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Asking whether the HOST has a device.
+ *
+ * A plugin cannot answer this itself. `stat("/dev/dri")` reports on the
+ * plugin's own filesystem, which is the Signal K container whenever Signal K
+ * is containerized — the common deployment — and that container has no
+ * `/dev/dri` even on a machine with a GPU. The result is a silent false
+ * negative: the plugin runs its workload under software rendering and nothing
+ * says why.
+ *
+ * signalk-container can see the host, so it answers instead.
+ */
+import type { ContainerManagerApi, HostDeviceProbeResult } from "./types.js";
+/**
+ * Probe a host path for device nodes and the groups that own them.
+ *
+ * ```ts
+ * const gpu = await probeHostDevice(manager, "/dev/dri");
+ * if (gpu?.exists) {
+ *   config.devices = ["/dev/dri"];
+ *   config.groupAdd = gpu.groups;   // names, resolved on the host
+ * }
+ * ```
+ *
+ * `groups` are NAMES rather than gids on purpose: `groupAdd` resolves names
+ * against the host's `/etc/group`, and the gid of `render` or `video` differs
+ * per distro and per install. Hardcoding a number — as the upstream
+ * opencpn-kiosk compose does with `group_add: "993"` — silently loses access
+ * on any host that numbers them differently.
+ *
+ * @returns the probe result, or **null meaning "unknown"** — no runtime, or
+ * the host could not be inspected. That is deliberately distinct from
+ * `{ exists: false }`, which means "definitely not there". Treat null as
+ * "assume no device, but do not report it as absent".
+ *
+ * @throws ContainerHelperError `unsupported-manager` on signalk-container
+ * older than 1.30.0, which has no probe at all. Catch it if the caller would
+ * rather degrade than fail.
+ */
+export declare function probeHostDevice(manager: ContainerManagerApi, path: string): Promise<HostDeviceProbeResult | null>;
+//# sourceMappingURL=host-device.d.ts.map

package/dist/host-device.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"host-device.d.ts","sourceRoot":"","sources":["../src/host-device.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAGH,OAAO,KAAK,EAAE,mBAAmB,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAE7E;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAsB,eAAe,CACnC,OAAO,EAAE,mBAAmB,EAC5B,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,qBAAqB,GAAG,IAAI,CAAC,CAevC"}

package/dist/host-device.js

@@ -0,0 +1,50 @@
+/**
+ * Asking whether the HOST has a device.
+ *
+ * A plugin cannot answer this itself. `stat("/dev/dri")` reports on the
+ * plugin's own filesystem, which is the Signal K container whenever Signal K
+ * is containerized — the common deployment — and that container has no
+ * `/dev/dri` even on a machine with a GPU. The result is a silent false
+ * negative: the plugin runs its workload under software rendering and nothing
+ * says why.
+ *
+ * signalk-container can see the host, so it answers instead.
+ */
+import { ContainerHelperError } from "./util.js";
+/**
+ * Probe a host path for device nodes and the groups that own them.
+ *
+ * ```ts
+ * const gpu = await probeHostDevice(manager, "/dev/dri");
+ * if (gpu?.exists) {
+ *   config.devices = ["/dev/dri"];
+ *   config.groupAdd = gpu.groups;   // names, resolved on the host
+ * }
+ * ```
+ *
+ * `groups` are NAMES rather than gids on purpose: `groupAdd` resolves names
+ * against the host's `/etc/group`, and the gid of `render` or `video` differs
+ * per distro and per install. Hardcoding a number — as the upstream
+ * opencpn-kiosk compose does with `group_add: "993"` — silently loses access
+ * on any host that numbers them differently.
+ *
+ * @returns the probe result, or **null meaning "unknown"** — no runtime, or
+ * the host could not be inspected. That is deliberately distinct from
+ * `{ exists: false }`, which means "definitely not there". Treat null as
+ * "assume no device, but do not report it as absent".
+ *
+ * @throws ContainerHelperError `unsupported-manager` on signalk-container
+ * older than 1.30.0, which has no probe at all. Catch it if the caller would
+ * rather degrade than fail.
+ */
+export async function probeHostDevice(manager, path) {
+    if (!path.startsWith("/")) {
+        throw new ContainerHelperError("invalid-option", `probeHostDevice: path must be absolute, got '${path}'`);
+    }
+    if (typeof manager.probeHostDevice !== "function") {
+        throw new ContainerHelperError("unsupported-manager", "probeHostDevice requires signalk-container 1.30.0+; " +
+            "upgrade it to detect host devices from a containerized Signal K");
+    }
+    return manager.probeHostDevice(path);
+}
+//# sourceMappingURL=host-device.js.map

package/dist/host-device.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"host-device.js","sourceRoot":"","sources":["../src/host-device.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,oBAAoB,EAAE,MAAM,WAAW,CAAC;AAGjD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,CAAC,KAAK,UAAU,eAAe,CACnC,OAA4B,EAC5B,IAAY;IAEZ,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC;QAC1B,MAAM,IAAI,oBAAoB,CAC5B,gBAAgB,EAChB,gDAAgD,IAAI,GAAG,CACxD,CAAC;IACJ,CAAC;IACD,IAAI,OAAO,OAAO,CAAC,eAAe,KAAK,UAAU,EAAE,CAAC;QAClD,MAAM,IAAI,oBAAoB,CAC5B,qBAAqB,EACrB,sDAAsD;YACpD,iEAAiE,CACpE,CAAC;IACJ,CAAC;IACD,OAAO,OAAO,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;AACvC,CAAC"}

package/dist/index.d.ts

@@ -8,10 +8,17 @@ export type { AdoptedContainerOptions } from "./adopted-container.js";
 export { buildVersionSource } from "./version-source.js";
 export type { VersionSourceSpec } from "./version-source.js";
 export { resolveMount } from "./host-path.js";
+export { probeHostDevice } from "./host-device.js";
 export type { HostMount, ResolveMountOptions } from "./host-path.js";
 export { retryForever, anySignal } from "./retry.js";
 export type { RetryForeverOptions } from "./retry.js";
 export { fetchWithTimeout, waitForHttpReady, probeHttpHealth } from "./http.js";
+export { resolveEndpoint, waitForEndpointReady, isManagedMode, describeEndpoint, } from "./endpoint.js";
+export type { EndpointMode, ResolvedEndpoint, ResolveEndpointOptions, EndpointReadyOptions, } from "./endpoint.js";
+export { normalizeExternalUrl } from "./url.js";
+export type { NormalizeUrlOptions, NormalizedUrl } from "./url.js";
+export { managedModeSchema } from "./schema.js";
+export type { JsonSchemaFragment, ManagedModeSchema, ManagedModeSchemaOptions, } from "./schema.js";
 export type { FetchLike, FetchWithTimeoutOptions, WaitForHttpReadyOptions, ProbeHttpHealthOptions, HealthProbeResult, } from "./http.js";
 export { startSafely, throwIfAborted, errMsg, isValidImageTag, IMAGE_TAG_PATTERN, ContainerHelperError, } from "./util.js";
 export type { ContainerHelperErrorCode } from "./util.js";

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,OAAO,EAAE,mBAAmB,EAAE,uBAAuB,EAAE,MAAM,cAAc,CAAC;AAC5E,YAAY,EAAE,qBAAqB,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAC7E,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC1D,YAAY,EACV,uBAAuB,EACvB,oBAAoB,EACpB,gBAAgB,EAChB,WAAW,EACX,UAAU,EACV,YAAY,EACZ,mBAAmB,EACnB,gBAAgB,GACjB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC1D,YAAY,EAAE,uBAAuB,EAAE,MAAM,wBAAwB,CAAC;AACtE,OAAO,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AACzD,YAAY,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAC7D,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,YAAY,EAAE,SAAS,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AACrE,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AACrD,YAAY,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AACtD,OAAO,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAChF,YAAY,EACV,SAAS,EACT,uBAAuB,EACvB,uBAAuB,EACvB,sBAAsB,EACtB,iBAAiB,GAClB,MAAM,WAAW,CAAC;AACnB,OAAO,EACL,WAAW,EACX,cAAc,EACd,MAAM,EACN,eAAe,EACf,iBAAiB,EACjB,oBAAoB,GACrB,MAAM,WAAW,CAAC;AACnB,YAAY,EAAE,wBAAwB,EAAE,MAAM,WAAW,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,OAAO,EAAE,mBAAmB,EAAE,uBAAuB,EAAE,MAAM,cAAc,CAAC;AAC5E,YAAY,EAAE,qBAAqB,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAC7E,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC1D,YAAY,EACV,uBAAuB,EACvB,oBAAoB,EACpB,gBAAgB,EAChB,WAAW,EACX,UAAU,EACV,YAAY,EACZ,mBAAmB,EACnB,gBAAgB,GACjB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC1D,YAAY,EAAE,uBAAuB,EAAE,MAAM,wBAAwB,CAAC;AACtE,OAAO,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AACzD,YAAY,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAC7D,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AACnD,YAAY,EAAE,SAAS,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AACrE,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AACrD,YAAY,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AACtD,OAAO,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAChF,OAAO,EACL,eAAe,EACf,oBAAoB,EACpB,aAAa,EACb,gBAAgB,GACjB,MAAM,eAAe,CAAC;AACvB,YAAY,EACV,YAAY,EACZ,gBAAgB,EAChB,sBAAsB,EACtB,oBAAoB,GACrB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAC;AAChD,YAAY,EAAE,mBAAmB,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AACnE,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAChD,YAAY,EACV,kBAAkB,EAClB,iBAAiB,EACjB,wBAAwB,GACzB,MAAM,aAAa,CAAC;AACrB,YAAY,EACV,SAAS,EACT,uBAAuB,EACvB,uBAAuB,EACvB,sBAAsB,EACtB,iBAAiB,GAClB,MAAM,WAAW,CAAC;AACnB,OAAO,EACL,WAAW,EACX,cAAc,EACd,MAAM,EACN,eAAe,EACf,iBAAiB,EACjB,oBAAoB,GACrB,MAAM,WAAW,CAAC;AACnB,YAAY,EAAE,wBAAwB,EAAE,MAAM,WAAW,CAAC"}

package/dist/index.js

@@ -4,7 +4,11 @@ export { ManagedContainer } from "./managed-container.js";
 export { AdoptedContainer } from "./adopted-container.js";
 export { buildVersionSource } from "./version-source.js";
 export { resolveMount } from "./host-path.js";
+export { probeHostDevice } from "./host-device.js";
 export { retryForever, anySignal } from "./retry.js";
 export { fetchWithTimeout, waitForHttpReady, probeHttpHealth } from "./http.js";
+export { resolveEndpoint, waitForEndpointReady, isManagedMode, describeEndpoint, } from "./endpoint.js";
+export { normalizeExternalUrl } from "./url.js";
+export { managedModeSchema } from "./schema.js";
 export { startSafely, throwIfAborted, errMsg, isValidImageTag, IMAGE_TAG_PATTERN, ContainerHelperError, } from "./util.js";
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,OAAO,EAAE,mBAAmB,EAAE,uBAAuB,EAAE,MAAM,cAAc,CAAC;AAE5E,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAW1D,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAE1D,OAAO,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAEzD,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE9C,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAErD,OAAO,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAQhF,OAAO,EACL,WAAW,EACX,cAAc,EACd,MAAM,EACN,eAAe,EACf,iBAAiB,EACjB,oBAAoB,GACrB,MAAM,WAAW,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,OAAO,EAAE,mBAAmB,EAAE,uBAAuB,EAAE,MAAM,cAAc,CAAC;AAE5E,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAW1D,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAE1D,OAAO,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAEzD,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAEnD,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAErD,OAAO,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAChF,OAAO,EACL,eAAe,EACf,oBAAoB,EACpB,aAAa,EACb,gBAAgB,GACjB,MAAM,eAAe,CAAC;AAOvB,OAAO,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAC;AAEhD,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAahD,OAAO,EACL,WAAW,EACX,cAAc,EACd,MAAM,EACN,eAAe,EACf,iBAAiB,EACjB,oBAAoB,GACrB,MAAM,WAAW,CAAC"}