homebridge-generac 0.1.0-beta.1

package/homebridge-ui/public/js/sections/account.js

@@ -0,0 +1,272 @@
+/**
+ * The Mobile Link account card in its four states (SPEC section 11.3 B) and the two-step Connect flow that
+ * replaces it in place (11.3 C). The card is drawn from /status and the page state on every redraw; the flow
+ * hands control back to it when it ends. The password and the code live in the flow state until the request
+ * that carries them returns, and are never written anywhere.
+ */
+import { callServer } from '../api.js';
+import { badge, card, cardName } from '../card.js';
+import { ACCOUNT, CONNECT } from '../copy.js';
+import { el, grid, gridCell, inlineConfirm, linkButton, outlineButton, paragraph, passwordField, primaryButton, statusBox, textField, } from '../dom.js';
+import { parseDate, relativeTime } from '../format.js';
+/** Checking this long after the sign-in, the card adds the restart line (SPEC section 11.3 B). */
+export const CHECKING_HINT_MS = 120 * 1000;
+function startFlow(app) {
+    app.ui.flow = { step: 'credentials', email: '', password: '', error: null, busy: false };
+    app.rerender('account');
+}
+/** Not connected; before the first /status answer the Connect button waits disabled. */
+function notConnectedCard(app, ready) {
+    const connect = primaryButton(ACCOUNT.connect, () => startFlow(app));
+    connect.disabled = !ready;
+    return card({
+        title: cardName(ACCOUNT.title),
+        body: [paragraph(ACCOUNT.notConnectedBody, 'gn-body'), el('div', { class: 'gn-actions' }, connect)],
+        cls: 'gn-account-card',
+    });
+}
+/** Signed in, and the platform has not polled with the new credentials yet: no button, one line, then the restart line. */
+function checkingCard(app, email) {
+    const since = app.ui.checkingSince;
+    const slow = since !== null && Date.now() - since >= CHECKING_HINT_MS;
+    return card({
+        title: cardName(ACCOUNT.title),
+        badges: [badge(ACCOUNT.checking, 'outline')],
+        body: [
+            email ? el('div', { class: 'gn-row' }, el('span', { class: 'gn-email' }, email)) : null,
+            paragraph(ACCOUNT.checkingBody, 'gn-body'),
+            slow ? paragraph(ACCOUNT.checkingSlow, 'gn-body') : null,
+        ],
+        cls: 'gn-account-card',
+    });
+}
+function connectedCard(app, email, lastChecked) {
+    const checked = parseDate(lastChecked);
+    const disconnect = inlineConfirm({
+        start: linkButton(ACCOUNT.disconnect, () => undefined, 'gn-disconnect'),
+        question: ACCOUNT.disconnectQuestion,
+        confirmLabel: ACCOUNT.disconnect,
+        confirmClass: 'btn btn-danger btn-sm',
+        cancelLabel: ACCOUNT.keep,
+        open: app.ui.disconnectOpen,
+        onOpen: (open) => {
+            app.ui.disconnectOpen = open;
+        },
+        onConfirm: () => {
+            void callServer('/disconnect').then(() => app.refreshStatus());
+            if (app.status) {
+                app.status.account = { state: 'not_connected' };
+            }
+            app.rerender('account');
+        },
+    });
+    return card({
+        title: cardName(ACCOUNT.title),
+        badges: [badge(ACCOUNT.connected, 'status')],
+        body: [
+            el('div', { class: 'gn-row' }, el('span', { class: 'gn-email' }, email)),
+            checked ? el('p', { class: 'gn-meta' }, ACCOUNT.lastChecked(relativeTime(checked))) : null,
+        ],
+        footerRight: disconnect,
+        cls: 'gn-account-card',
+    });
+}
+function reconnectCard(app, email) {
+    return card({
+        title: cardName(ACCOUNT.title),
+        badges: [badge(ACCOUNT.reconnectBadge, 'warn')],
+        body: [
+            email ? el('div', { class: 'gn-row' }, el('span', { class: 'gn-email' }, email)) : null,
+            paragraph(ACCOUNT.reconnectBody, 'gn-body'),
+            app.config.attentionSensor ? paragraph(ACCOUNT.reconnectAttention, 'gn-body') : null,
+            el('div', { class: 'gn-actions' }, primaryButton(ACCOUNT.reconnect, () => startFlow(app))),
+        ],
+        cls: 'gn-account-card',
+    });
+}
+// ---------------------------------------------------------------------------
+// Connect flow (SPEC section 11.3 C)
+// ---------------------------------------------------------------------------
+function endFlow(app) {
+    void callServer('/connect/cancel');
+    app.ui.flow = null;
+    app.rerender('account');
+}
+/**
+ * The sign-in finished: the flow ends and the card renderer takes over. The platform picks the credentials up
+ * within a minute, so the card reads Checking until /status says otherwise; every /status answer redraws it.
+ */
+function finishFlow(app, email) {
+    app.ui.flow = null;
+    app.ui.checkingSince = Date.now();
+    if (app.status) {
+        app.status.account = { state: 'checking', email };
+    }
+    app.rerender('account');
+    void app.refreshStatus();
+}
+const START_ERRORS = {
+    wrong_password: CONNECT.wrongPassword,
+    unknown_email: CONNECT.unknownEmail,
+    network: CONNECT.network,
+};
+const CODE_ERRORS = {
+    wrong_code: CONNECT.wrongCode,
+    too_many: CONNECT.tooMany,
+    expired: CONNECT.expired,
+};
+function credentialsCard(app, flow) {
+    const email = textField(CONNECT.email, flow.email, (v) => {
+        flow.email = v;
+    }, { path: 'connect.email', type: 'email', required: true, placeholder: CONNECT.emailPlaceholder, autocomplete: 'username', inputmode: 'email' });
+    const password = passwordField(CONNECT.password, flow.password, (v) => {
+        flow.password = v;
+    }, { path: 'connect.password', required: true, help: CONNECT.passwordHelp });
+    const signIn = primaryButton(flow.busy ? CONNECT.signingIn : CONNECT.signIn, () => {
+        if (flow.busy) {
+            return;
+        }
+        const missing = [!flow.email.trim() ? 'connect.email' : null, !flow.password ? 'connect.password' : null].filter((p) => p !== null);
+        if (missing.length > 0) {
+            for (const path of missing) {
+                app.touch(path);
+            }
+            return;
+        }
+        flow.busy = true;
+        flow.error = null;
+        app.rerender('account');
+        const submitted = { email: flow.email.trim(), password: flow.password };
+        void callServer('/connect/start', submitted).then((r) => {
+            if (app.ui.flow !== flow) {
+                return;
+            }
+            flow.busy = false;
+            if (r && 'step' in r) {
+                if (r.step === 'done') {
+                    finishFlow(app, submitted.email);
+                    return;
+                }
+                app.ui.flow = { step: 'code', method: r.method, email: submitted.email, code: '', error: null, busy: false };
+            }
+            else if (r && 'error' in r && r.error === 'unsupported_factor') {
+                app.ui.flow = { step: 'unsupported' };
+            }
+            else {
+                const code = r && 'error' in r ? r.error : 'network';
+                flow.error = code in START_ERRORS ? code : 'network';
+                flow.password = '';
+            }
+            app.rerender('account');
+        });
+    });
+    signIn.disabled = flow.busy;
+    const cancel = linkButton(CONNECT.cancel, () => endFlow(app));
+    cancel.disabled = flow.busy;
+    return card({
+        title: cardName(ACCOUNT.title),
+        body: [
+            grid(gridCell(6, email), gridCell(6, password)),
+            flow.error ? statusBox('danger', START_ERRORS[flow.error]) : null,
+            el('div', { class: 'gn-actions' }, signIn, cancel),
+        ],
+        cls: 'gn-account-card gn-connect',
+    });
+}
+function codeCard(app, flow) {
+    const body = flow.method === 'sms' ? CONNECT.codeBodySms : flow.method === 'otp' ? CONNECT.codeBodyOtp : CONNECT.codeBodyEmail(flow.email);
+    const locked = flow.error === 'too_many' || flow.error === 'expired';
+    const code = textField(CONNECT.code, flow.code, (v) => {
+        flow.code = v;
+    }, { path: 'connect.code', required: true, monospace: true, placeholder: CONNECT.codePlaceholder, autocomplete: 'one-time-code', inputmode: 'numeric' });
+    const proceed = primaryButton(CONNECT.continue, () => {
+        if (flow.busy || locked) {
+            return;
+        }
+        if (!flow.code.trim()) {
+            app.touch('connect.code');
+            return;
+        }
+        flow.busy = true;
+        flow.error = null;
+        app.rerender('account');
+        const submitted = flow.code.trim();
+        void callServer('/connect/code', { code: submitted }).then((r) => {
+            if (app.ui.flow !== flow) {
+                return;
+            }
+            flow.busy = false;
+            flow.code = '';
+            app.untouch('connect.code');
+            if (r && 'step' in r && r.step === 'done') {
+                finishFlow(app, flow.email);
+                return;
+            }
+            const error = r && 'error' in r ? r.error : 'expired';
+            flow.error = error in CODE_ERRORS ? error : 'expired';
+            app.rerender('account');
+        });
+    });
+    proceed.disabled = flow.busy || locked;
+    const cancel = linkButton(CONNECT.cancel, () => endFlow(app));
+    cancel.disabled = flow.busy;
+    const node = card({
+        title: cardName(CONNECT.codeTitle),
+        body: [
+            paragraph(body, 'gn-body'),
+            paragraph(CONNECT.codeSecondLine, 'gn-body'),
+            grid(gridCell(4, code)),
+            flow.error ? statusBox('danger', CODE_ERRORS[flow.error]) : null,
+            el('div', { class: 'gn-actions' }, proceed, cancel),
+        ],
+        cls: 'gn-account-card gn-connect',
+    });
+    if (!flow.busy && !locked) {
+        window.setTimeout(() => node.querySelector('input')?.focus(), 0);
+    }
+    return node;
+}
+function unsupportedCard(app) {
+    return card({
+        title: cardName(ACCOUNT.title),
+        body: [
+            paragraph(CONNECT.unsupported, 'gn-body'),
+            el('div', { class: 'gn-actions' }, outlineButton(CONNECT.cancel, () => endFlow(app))),
+        ],
+        cls: 'gn-account-card gn-connect',
+    });
+}
+function renderFlow(app, flow) {
+    switch (flow.step) {
+        case 'credentials':
+            return credentialsCard(app, flow);
+        case 'code':
+            return codeCard(app, flow);
+        default:
+            return unsupportedCard(app);
+    }
+}
+export function renderAccount(app, container) {
+    if (app.ui.flow) {
+        container.appendChild(renderFlow(app, app.ui.flow));
+        return;
+    }
+    const account = app.status?.account;
+    if (!account) {
+        container.appendChild(notConnectedCard(app, false));
+        return;
+    }
+    switch (account.state) {
+        case 'connected':
+            container.appendChild(connectedCard(app, account.email ?? '', account.lastChecked));
+            break;
+        case 'reconnect_needed':
+            container.appendChild(reconnectCard(app, account.email ?? ''));
+            break;
+        case 'checking':
+            container.appendChild(checkingCard(app, account.email ?? ''));
+            break;
+        default:
+            container.appendChild(notConnectedCard(app, true));
+    }
+}

package/homebridge-ui/public/js/sections/generators.js

@@ -0,0 +1,165 @@
+/**
+ * The Generators section (SPEC section 11.3 D): one card per generator with its status badges, fault reasons,
+ * the detail rows, and Rename in the footer editing in place; the empty line; and the "Also on your account"
+ * lines for the devices the plugin skips.
+ */
+import { badge, card } from '../card.js';
+import { GENERATOR, INTRO, SHELL } from '../copy.js';
+import { button, el, footerAction, linkButton, paragraph, textField } from '../dom.js';
+import { formatDate, formatTime, formatTimeOrDate, formatVolts, hhmmTo12h, parseDate, relativeTime } from '../format.js';
+import { overrideFor, setOverride } from '../model.js';
+const STATUS = { READY: 1, RUNNING: 2, EXERCISING: 3 };
+const DEVICE = { PROPANE_MONITOR: 2, LINKED_ECOBEE: 7 };
+export function displayName(app, g) {
+    return overrideFor(app.config, g.id) ?? g.name;
+}
+/** The status badges of a card (SPEC section 11.3 D). */
+export function statusBadges(g) {
+    if (!g.connected) {
+        return [[GENERATOR.notResponding, 'muted']];
+    }
+    const out = [];
+    if (g.status === STATUS.RUNNING) {
+        out.push([GENERATOR.running, 'running']);
+    }
+    else if (g.status === STATUS.EXERCISING) {
+        out.push([GENERATOR.exercising, 'exercising']);
+    }
+    else if (g.status === STATUS.READY) {
+        out.push([g.statusLabel || GENERATOR.ready, 'ready']);
+    }
+    else if (!g.fault && g.statusLabel) {
+        out.push([g.statusLabel, 'muted']);
+    }
+    if (g.fault) {
+        out.push([GENERATOR.fault, 'fault']);
+    }
+    return out;
+}
+function row(label, ...value) {
+    return [el('dt', {}, label), el('dd', {}, ...value)];
+}
+/** The inline Name field with Save name and Cancel (SPEC section 11.3 D); "Name is required." on blur. */
+function renameEditor(app, g, rename, titleNode) {
+    const path = `generators[${g.id}].name`;
+    const field = textField(GENERATOR.name, rename.value, (v) => {
+        rename.value = v;
+        titleNode.textContent = v.trim() || g.name;
+    }, { path, required: true });
+    const feedback = field.querySelector('.invalid-feedback');
+    const input = field.querySelector('input');
+    const showRequired = () => {
+        const missing = !rename.value.trim();
+        field.classList.toggle('has-issue', missing);
+        input.classList.toggle('is-invalid', missing);
+        if (feedback) {
+            feedback.textContent = missing ? SHELL.required(GENERATOR.name) : '';
+        }
+        return missing;
+    };
+    const save = button(GENERATOR.saveName, () => {
+        if (showRequired()) {
+            input.focus();
+            return;
+        }
+        setOverride(app.config, g.id, rename.value, g.name);
+        app.ui.rename = null;
+        app.changed();
+        app.rerender('generators');
+    }, 'btn btn-primary btn-sm');
+    const cancel = linkButton(GENERATOR.cancel, () => {
+        app.ui.rename = null;
+        app.rerender('generators');
+    });
+    input.addEventListener('blur', () => showRequired());
+    input.addEventListener('input', () => {
+        if (rename.value.trim()) {
+            showRequired();
+        }
+    });
+    input.addEventListener('keydown', (event) => {
+        if (event.key === 'Enter') {
+            event.preventDefault();
+            save.click();
+        }
+        else if (event.key === 'Escape') {
+            event.preventDefault();
+            cancel.click();
+        }
+    });
+    window.setTimeout(() => {
+        input.focus();
+        input.select();
+    }, 0);
+    return el('span', { class: 'gn-rename-editor' }, field, el('span', { class: 'gn-rename-actions' }, save, cancel));
+}
+function generatorCard(app, g) {
+    const name = displayName(app, g);
+    const title = el('span', { class: 'gn-title-block' }, el('span', { class: 'ns-card-name' }, name), el('span', { class: 'gn-model' }, g.model), el('span', { class: 'gn-serial' }, GENERATOR.serial(g.serial)));
+    const badges = g.maintenanceDue ? [badge(GENERATOR.maintenanceDue, 'warn')] : [];
+    const statusRow = el('div', { class: 'gn-status' }, ...statusBadges(g).map(([text, kind]) => badge(text, kind)));
+    const lastSeen = parseDate(g.lastSeen);
+    if (!g.connected) {
+        statusRow.appendChild(el('span', { class: 'gn-note' }, GENERATOR.notRespondingNote(lastSeen ? formatTimeOrDate(lastSeen) : '?')));
+    }
+    else if (g.fault && g.faultReasons.length > 0) {
+        statusRow.appendChild(el('ul', { class: 'gn-reasons' }, ...g.faultReasons.map((r) => el('li', {}, r))));
+    }
+    const rows = [];
+    if (g.batteryVoltage !== null) {
+        const low = g.batteryVoltage <= app.config.batteryLowVoltage;
+        rows.push(...row(GENERATOR.battery, GENERATOR.volts(formatVolts(g.batteryVoltage)), low ? badge(GENERATOR.low, 'warn') : null));
+    }
+    if (g.fuelType === 'propane' && typeof g.fuelPercent === 'number') {
+        rows.push(...row(GENERATOR.fuel, GENERATOR.percent(String(Math.round(g.fuelPercent))), el('span', { class: 'gn-help' }, GENERATOR.fuelHelp)));
+    }
+    if (g.engineHours !== null) {
+        rows.push(...row(GENERATOR.engineHours, GENERATOR.hours(String(g.engineHours))));
+    }
+    const exercise = hhmmTo12h(app.config.exerciseTime) ?? hhmmTo12h(g.exerciseTimeFromApi) ?? g.exerciseTime;
+    if (exercise) {
+        rows.push(...row(GENERATOR.exerciseTime, GENERATOR.weekly(exercise)));
+    }
+    const lastExercise = parseDate(g.lastExerciseAt);
+    if (lastExercise) {
+        rows.push(...row(GENERATOR.lastExercise, GENERATOR.dateAt(formatDate(lastExercise), formatTime(lastExercise))));
+    }
+    if (lastSeen) {
+        rows.push(...row(GENERATOR.lastSeen, relativeTime(lastSeen)));
+    }
+    const footer = el('span', { class: 'gn-rename' });
+    const rename = app.ui.rename;
+    if (rename && rename.id === g.id) {
+        footer.appendChild(renameEditor(app, g, rename, title.firstElementChild));
+    }
+    else {
+        footer.appendChild(footerAction(GENERATOR.rename, () => {
+            app.ui.rename = { id: g.id, value: name };
+            app.rerender('generators');
+        }));
+    }
+    return card({
+        title,
+        badges,
+        body: [statusRow, rows.length > 0 ? el('dl', { class: 'gn-kv' }, ...rows) : null],
+        footerRight: footer,
+        cls: 'gn-generator-card',
+    });
+}
+export function renderGenerators(app, container) {
+    const generators = app.status?.generators ?? [];
+    if (generators.length === 0) {
+        container.appendChild(paragraph(INTRO.generatorsEmpty, 'gn-empty'));
+    }
+    for (const g of generators) {
+        container.appendChild(generatorCard(app, g));
+    }
+    for (const other of app.status?.others ?? []) {
+        if (other.type === DEVICE.PROPANE_MONITOR) {
+            container.appendChild(paragraph(GENERATOR.alsoPropane, 'gn-also'));
+        }
+        else if (other.type === DEVICE.LINKED_ECOBEE) {
+            container.appendChild(paragraph(GENERATOR.alsoEcobee(other.name), 'gn-also'));
+        }
+    }
+}

package/homebridge-ui/public/js/sections/settings.js

@@ -0,0 +1,114 @@
+/**
+ * The Settings section (SPEC section 11.3 E): one collapsed disclosure holding every platform setting, and the
+ * Reset dialog. Validation runs on blur through the page; the messages come from copy.ts.
+ */
+import { callServer, toastSuccess } from '../api.js';
+import { SETTINGS, SHELL } from '../copy.js';
+import { button, checkboxField, dangerLinkButton, disclosure, el, grid, gridCell, inlineDialog, linkButton, numberField, reveal, textField, } from '../dom.js';
+import { formatVolts } from '../format.js';
+import { DEFAULTS, emptyConfig } from '../model.js';
+import { hasOneDecimal } from '../validate.js';
+/**
+ * The Reset dialog: the three lines from SPEC section 11.3 E, "Type RESET to confirm.", Confirm disabled until
+ * typed. It renders inline directly below the Reset link (SPEC section 11.2) and is page state, so a redraw of
+ * the section keeps it open; opening it by click focuses the field and scrolls the host modal to the dialog.
+ */
+function resetDialog(app, opened) {
+    const confirmInput = el('input', { type: 'text', class: 'form-control', autocomplete: 'off', spellcheck: 'false', id: 'gn-reset-confirm' });
+    let close = () => undefined;
+    const confirm = button(SHELL.resetConfirm, () => {
+        close();
+        // Sign out and forget the saved state on the server; the platform removes the accessories on its next start.
+        void callServer('/reset').then(() => app.refreshStatus());
+        if (app.status) {
+            app.status.account = { state: 'not_connected' };
+        }
+        app.ui.flow = null;
+        app.ui.disconnectOpen = false;
+        app.ui.rename = null;
+        app.replaceConfig(emptyConfig());
+        toastSuccess(SHELL.resetDone);
+    }, 'btn btn-danger btn-sm');
+    confirm.disabled = true;
+    confirmInput.addEventListener('input', () => {
+        confirm.disabled = confirmInput.value.trim() !== 'RESET';
+    });
+    const dialog = inlineDialog({
+        title: SHELL.resetTitle,
+        body: el('div', {}, el('ul', { class: 'ps-3' }, ...SETTINGS.resetLines.map((line) => el('li', {}, line))), el('label', { class: 'form-label', for: 'gn-reset-confirm' }, SHELL.resetPrompt), confirmInput),
+        actions: [confirm, linkButton(SHELL.resetCancel, () => close())],
+        onClose: () => {
+            app.ui.resetOpen = false;
+        },
+    });
+    close = dialog.close;
+    if (opened) {
+        window.setTimeout(() => {
+            confirmInput.focus();
+            reveal(dialog.el);
+        }, 0);
+    }
+    return dialog.el;
+}
+/** The Reset link, with the dialog directly below it while open. */
+function resetControl(app) {
+    const holder = el('div', { class: 'gn-reset' });
+    const link = dangerLinkButton(SHELL.reset, () => {
+        if (app.ui.resetOpen) {
+            return;
+        }
+        app.ui.resetOpen = true;
+        holder.appendChild(resetDialog(app, true));
+    });
+    holder.appendChild(link);
+    if (app.ui.resetOpen) {
+        holder.appendChild(resetDialog(app, false));
+    }
+    return holder;
+}
+export function renderSettings(app, container) {
+    const c = app.config;
+    const fields = grid(gridCell(6, textField(SETTINGS.name, c.name, (v) => {
+        c.name = v;
+        app.changed();
+    }, { path: 'name', required: true })), gridCell(6), gridCell(6, numberField(SETTINGS.pollIdle, c.pollIdleMinutes, (v) => {
+        c.pollIdleMinutes = v;
+        app.changed();
+    }, { path: 'pollIdleMinutes', min: DEFAULTS.pollIdleMinutesMin, help: SETTINGS.pollIdleHelp })), gridCell(6, numberField(SETTINGS.pollActive, c.pollActiveSeconds, (v) => {
+        c.pollActiveSeconds = v;
+        app.changed();
+    }, { path: 'pollActiveSeconds', min: DEFAULTS.pollActiveSecondsMin, help: SETTINGS.pollActiveHelp })), gridCell(6, numberField(SETTINGS.batteryLow, c.batteryLowVoltage, (v) => {
+        c.batteryLowVoltage = v;
+        app.changed();
+    }, {
+        path: 'batteryLowVoltage', step: '0.1', help: SETTINGS.batteryLowHelp,
+        // One decimal place on load and after blur (12.0, 11.8); more than one keeps its text and its message (SPEC section 11.3 E).
+        format: (v) => (hasOneDecimal(v) ? formatVolts(v) : null),
+    })), gridCell(6), gridCell(12, checkboxField(SETTINGS.faultOnStopped, c.faultOnStopped, (v) => {
+        c.faultOnStopped = v;
+        app.changed();
+    }, { path: 'faultOnStopped', help: SETTINGS.faultOnStoppedHelp })), gridCell(12, checkboxField(SETTINGS.faultOnDisconnected, c.faultOnDisconnected, (v) => {
+        c.faultOnDisconnected = v;
+        app.changed();
+    }, { path: 'faultOnDisconnected', help: SETTINGS.faultOnDisconnectedHelp })), gridCell(12, checkboxField(SETTINGS.attentionSensor, c.attentionSensor, (v) => {
+        c.attentionSensor = v;
+        app.changed();
+        // The Reconnect needed card mentions the sensor only while it is on.
+        app.rerender('account');
+    }, { path: 'attentionSensor', help: SETTINGS.attentionSensorHelp })), gridCell(12, checkboxField(SETTINGS.exerciseSensor, c.exerciseSensor, (v) => {
+        c.exerciseSensor = v;
+        app.changed();
+    }, { path: 'exerciseSensor', help: SETTINGS.exerciseSensorHelp })), gridCell(6, textField(SETTINGS.exerciseTime, c.exerciseTime, (v) => {
+        c.exerciseTime = v;
+        app.changed();
+        // The generator card's Exercise time row shows the configured value.
+        app.rerender('generators');
+    }, { path: 'exerciseTime', placeholder: SETTINGS.exerciseTimePlaceholder, help: SETTINGS.exerciseTimeHelp, inputmode: 'numeric', monospace: true })), gridCell(6, numberField(SETTINGS.exerciseHold, c.exerciseHoldMinutes, (v) => {
+        c.exerciseHoldMinutes = v;
+        app.changed();
+    }, { path: 'exerciseHoldMinutes', min: DEFAULTS.exerciseHoldMinutesMin, help: SETTINGS.exerciseHoldHelp })), gridCell(12, checkboxField(SETTINGS.debug, c.debug, (v) => {
+        c.debug = v;
+        app.changed();
+    }, { path: 'debug', help: SETTINGS.debugHelp })));
+    container.appendChild(disclosure(SHELL.advanced, [fields, resetControl(app)], { cls: 'gn-settings' }));
+}

package/homebridge-ui/public/js/validate.js

@@ -0,0 +1,45 @@
+/**
+ * Validation of the Settings disclosure (SPEC section 11.3 E), mirroring config.schema.json so the host's Save
+ * stays disabled while the file would fail its own checks. Each issue carries the field path for inline marking.
+ */
+import { SETTINGS, SHELL } from './copy.js';
+import { DEFAULTS } from './model.js';
+export const HHMM_PATTERN = /^([01]\d|2[0-3]):[0-5]\d$/;
+/** True for a finite number with at most one decimal place (12, 12.0 and 11.8; not 12.05). */
+export function hasOneDecimal(value) {
+    return Number.isFinite(value) && Math.round(value * 10) / 10 === value;
+}
+export function validate(config) {
+    const issues = [];
+    if (!config.name.trim()) {
+        issues.push({ path: 'name', message: SHELL.required(SETTINGS.name) });
+    }
+    if (!Number.isFinite(config.pollIdleMinutes)) {
+        issues.push({ path: 'pollIdleMinutes', message: SHELL.required(SETTINGS.pollIdle) });
+    }
+    else if (config.pollIdleMinutes < DEFAULTS.pollIdleMinutesMin) {
+        issues.push({ path: 'pollIdleMinutes', message: SETTINGS.pollIdleError });
+    }
+    if (!Number.isFinite(config.pollActiveSeconds)) {
+        issues.push({ path: 'pollActiveSeconds', message: SHELL.required(SETTINGS.pollActive) });
+    }
+    else if (config.pollActiveSeconds < DEFAULTS.pollActiveSecondsMin) {
+        issues.push({ path: 'pollActiveSeconds', message: SETTINGS.pollActiveError });
+    }
+    if (!Number.isFinite(config.batteryLowVoltage)) {
+        issues.push({ path: 'batteryLowVoltage', message: SHELL.required(SETTINGS.batteryLow) });
+    }
+    else if (!hasOneDecimal(config.batteryLowVoltage)) {
+        issues.push({ path: 'batteryLowVoltage', message: SETTINGS.batteryLowError });
+    }
+    if (config.exerciseTime.trim() && !HHMM_PATTERN.test(config.exerciseTime.trim())) {
+        issues.push({ path: 'exerciseTime', message: SETTINGS.exerciseTimeError });
+    }
+    if (!Number.isFinite(config.exerciseHoldMinutes)) {
+        issues.push({ path: 'exerciseHoldMinutes', message: SHELL.required(SETTINGS.exerciseHold) });
+    }
+    else if (config.exerciseHoldMinutes < DEFAULTS.exerciseHoldMinutesMin) {
+        issues.push({ path: 'exerciseHoldMinutes', message: SETTINGS.exerciseHoldError });
+    }
+    return issues;
+}

package/homebridge-ui/server.js

@@ -0,0 +1,8 @@
+/**
+ * Entry point the Homebridge UI starts for this plugin's settings page (SPEC section 10). The implementation
+ * is compiled from src/ui/server.ts into dist/ui/server.js and shares the auth, credentials and state modules
+ * with the platform, so nothing here duplicates them.
+ */
+import { startUiServer } from '../dist/ui/server.js';
+
+startUiServer();

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "homebridge-generac",
+  "displayName": "Generac",
+  "type": "module",
+  "version": "0.1.0-beta.1",
+  "description": "Generac Mobile Link standby generators in HomeKit: running, fault and maintenance sensors plus starting-battery health.",
+  "author": "Alex Rodriguez (https://alex-rodriguez.com)",
+  "license": "Apache-2.0",
+  "homepage": "https://github.com/arodbuilds/homebridge-generac#readme",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/arodbuilds/homebridge-generac.git"
+  },
+  "bugs": {
+    "url": "https://github.com/arodbuilds/homebridge-generac/issues"
+  },
+  "keywords": [
+    "homebridge-plugin",
+    "supports-hap",
+    "generac",
+    "mobilelink",
+    "mobile link",
+    "generator",
+    "standby generator",
+    "homekit"
+  ],
+  "main": "dist/index.js",
+  "bin": {
+    "homebridge-generac": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "homebridge-ui/public",
+    "homebridge-ui/server.js",
+    "config.schema.json",
+    "LICENSE",
+    "NOTICE",
+    "README.md",
+    "CHANGELOG.md",
+    "SECURITY.md"
+  ],
+  "engines": {
+    "node": "^20.18.0 || ^22.10.0",
+    "homebridge": "^1.8.0 || ^2.0.0-beta.0"
+  },
+  "scripts": {
+    "build": "rimraf ./dist && tsc && npm run build:ui",
+    "lint": "eslint . --max-warnings=0",
+    "prepublishOnly": "npm run lint && npm run build",
+    "test": "npm run lint && npm run build && npm run test:unit",
+    "test:unit": "rimraf ./build-test && tsc -p tsconfig.test.json && node --test build-test/test/*.test.js",
+    "watch": "npm run build && npm link && nodemon",
+    "build:ui": "rimraf ./homebridge-ui/public/js && tsc -p homebridge-ui && node scripts/build-ui.mjs"
+  },
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "@homebridge/hap-nodejs": "^2.2.3",
+    "@types/node": "^26.2.0",
+    "eslint": "^10.9.0",
+    "homebridge": "^2.4.0",
+    "nodemon": "^3.1.14",
+    "rimraf": "^6.1.3",
+    "ts-node": "^10.9.2",
+    "typescript": "^6.0.3",
+    "typescript-eslint": "^8.67.0"
+  },
+  "dependencies": {
+    "@homebridge/plugin-ui-utils": "^2.2.6"
+  }
+}