@khalido/home 0.0.0-stage → 0.1.1

package/dist/connectors/daikin/index.d.ts

@@ -0,0 +1,41 @@
+import { type Clock } from "../../clock.ts";
+import { z } from "zod";
+import type { Integration } from "../../home.ts";
+import { type Finder } from "../../discover.ts";
+import type { Manifest } from "../../manifest.ts";
+import { daikinClient, type DaikinState } from "./client.ts";
+export { DaikinError, type DaikinState, daikinClient, type Fan, type Mode, setFan, setMode, setPower, setTarget, type WriteRequest, } from "./client.ts";
+/** Poll every 120 s, as Home Assistant's daikin integration does (its coordinator's update_interval). */
+export declare const POLL_MS = 120000;
+/** A Daikin AC in a home config: its last known address, and the MAC its UDP discovery reports, which is how it is recognised. */
+export declare const configSchema: z.ZodObject<{
+    connector: z.ZodLiteral<"daikin">;
+    host: z.ZodString;
+    mac: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+/** Daikin settings: its last known address, its MAC and a UDP discovery to find it again if it moves (both optional), and a `fetch`. */
+export type DaikinConfig = {
+    host: string;
+    mac?: string;
+    find?: Finder;
+    fetch: typeof fetch;
+    clock?: Clock;
+    seen?: (host: string) => void;
+    hostCached?: boolean;
+};
+/** What the snapshot holds: the latest reading and when it was taken. */
+export type DaikinSnapshot = DaikinState & {
+    asOf: string;
+};
+/** What `daikin().client` is: the reads and writes of the unit, at wherever it is now. */
+export type DaikinClient = ReturnType<typeof daikinClient>;
+/**
+ * One Daikin AC as a home integration: one read now, then every 120 s. Its writes are `client.write(setPower(true))`: one
+ * client for the integration's life, so the writes share its lane and follow the unit when it moves.
+ */
+export declare function daikin(config: DaikinConfig): Integration<DaikinSnapshot, "daikin"> & {
+    readonly client: DaikinClient;
+};
+/** The AC in a few words: "off · cool 25 °C · room 24 °C · outdoor unit 19.5 °C". */
+export declare function acText(s: DaikinState): string;
+export declare const manifest: Manifest<DaikinSnapshot>;

package/dist/connectors/daikin/index.js

@@ -0,0 +1,108 @@
+import { asOf, realClock } from "../../clock.js";
+import { z } from "zod";
+import { lostDetail, relocator } from "../../discover.js";
+import { poller } from "../../poll.js";
+import { daikinClient, DaikinError } from "./client.js";
+export { DaikinError, daikinClient, setFan, setMode, setPower, setTarget, } from "./client.js";
+/** Poll every 120 s, as Home Assistant's daikin integration does (its coordinator's update_interval). */
+export const POLL_MS = 120_000;
+/** A Daikin AC in a home config: its last known address, and the MAC its UDP discovery reports, which is how it is recognised. */
+export const configSchema = z.looseObject({
+    connector: z.literal("daikin"),
+    host: z.string().describe("the unit's last known address"),
+    mac: z
+        .string()
+        .optional()
+        .describe("the unit's MAC as its UDP discovery reports it: its identity"),
+});
+/**
+ * One Daikin AC as a home integration: one read now, then every 120 s. Its writes are `client.write(setPower(true))`: one
+ * client for the integration's life, so the writes share its lane and follow the unit when it moves.
+ */
+export function daikin(config) {
+    const clock = config.clock ?? realClock;
+    const where = relocator({
+        host: config.host,
+        id: config.mac,
+        find: config.find,
+        clock,
+        cached: config.hostCached,
+    });
+    const client = daikinClient({
+        ...config,
+        get host() {
+            return where.host();
+        },
+    });
+    const poll = poller(clock);
+    return {
+        name: "daikin",
+        client,
+        refresh: () => (where.reset(), poll.nudge()),
+        async run(signal, update) {
+            let last;
+            let moved; // kept in `detail` so a consumer can persist the new address
+            while (!signal.aborted) {
+                try {
+                    last = { ...(await client.read(signal)), asOf: asOf(clock) };
+                    where.ok();
+                    config.seen?.(where.host());
+                    update({
+                        status: "connected",
+                        detail: moved,
+                        anomaly: last.anomaly,
+                        state: last,
+                    });
+                }
+                catch (error) {
+                    if (signal.aborted)
+                        return; // stopped mid-read: not a failure
+                    // A 404 is a failed read like any other: the address may now be another device's, so discovery looks for the unit.
+                    const why = error instanceof DaikinError && error.status === 404
+                        ? "no /dsiot/multireq at this address: not a dsiot Daikin"
+                        : error;
+                    const r = await where.failed(signal);
+                    if (r.moved) {
+                        moved = r.moved;
+                        continue; // read at the new address now; that read reports, with the move in `detail`
+                    }
+                    update({
+                        status: "disconnected",
+                        detail: lostDetail(r, why),
+                        state: last,
+                    });
+                }
+                await poll.wait(POLL_MS, signal);
+            }
+        },
+    };
+}
+/** The AC in a few words: "off · cool 25 °C · room 24 °C · outdoor unit 19.5 °C". */
+export function acText(s) {
+    const setting = [s.mode, s.targetC === undefined ? "" : `${s.targetC} °C`]
+        .filter(Boolean)
+        .join(" ");
+    return [
+        s.on === undefined ? "" : s.on ? "on" : "off",
+        setting,
+        s.roomC === undefined ? "" : `room ${s.roomC} °C`,
+        s.outsideC === undefined ? "" : `outdoor unit ${s.outsideC} °C`,
+    ]
+        .filter(Boolean)
+        .join(" · ");
+}
+export const manifest = {
+    name: "daikin",
+    title: "Daikin",
+    iotClass: "local_polling",
+    pollSeconds: POLL_MS / 1000,
+    access: "local HTTP JSON (dsiot), no key",
+    env: [
+        {
+            name: "DAIKIN_HOST",
+            example: "192.0.2.20",
+            what: "the unit's address; `home probe` finds it by UDP broadcast",
+        },
+    ],
+    lines: ({ state }) => (state ? [acText(state)] : []),
+};

package/dist/connectors/enphase/client.d.ts

@@ -0,0 +1,65 @@
+import { ConnectorError } from "../../connector.ts";
+/** A failed Enphase call. `status` 401 means the token is wrong or expired. */
+export declare class EnphaseError extends ConnectorError {
+}
+/** Solar right now and today. Watts and watt-hours as the gateway reports them, negatives included. */
+export type EnphaseState = {
+    productionW?: number;
+    productionWhToday?: number;
+    productionWhLifetime?: number;
+    consumptionW?: number;
+    consumptionWhToday?: number;
+    consumptionWhLifetime?: number;
+    netW?: number;
+    source: "meter" | "inverters";
+    readingTime?: string;
+    anomaly?: string;
+};
+/**
+ * Map `/production.json` and `/ivp/meters` to a state. A meter counts only when `/ivp/meters` says
+ * "enabled" and its reading has `activeCount > 0` (KO's v1 code, pyenphase); else production falls back to the inverters.
+ */
+export declare function toState(production: unknown, meters: unknown): EnphaseState;
+/**
+ * Map `/ivp/meters` and `/ivp/meters/readings` to a state: ~100 ms on KO's gateway against 1–10 s for
+ * `/production.json` (measured, Bun 1.4.2). Consumption is production plus net import on a net-consumption meter,
+ * or read directly from a total-consumption meter (pyenphase's meter types). No daily totals here: callers count today.
+ */
+export declare function fromReadings(meters: unknown, readings: unknown): EnphaseState;
+/** What a gateway client needs: its LAN address, an owner token, and a `fetch` that accepts its certificate. */
+export type EnphaseOptions = {
+    host: string;
+    token: string;
+    fetch: typeof fetch;
+};
+/** The gateway's address as a bare host: a scheme prefix and a trailing slash, as people paste it, are dropped. */
+export declare const gatewayHost: (host: string) => string;
+/** A read-only client for the IQ Gateway's local API (software 7 and later). */
+export declare function enphaseClient(options: EnphaseOptions): {
+    get: (path: string, signal?: AbortSignal) => Promise<unknown>;
+    /** Production, consumption and net now: the fast meter readings when a production meter is on, else `/production.json`. */
+    read(signal?: AbortSignal): Promise<EnphaseState>;
+};
+/** When a JWT expires, from its `exp` claim. Throws on anything that is not a JWT. */
+export declare function tokenExpiry(token: string): Date;
+/** Whole days until `expiresAt`, negative once expired. */
+export declare const daysLeft: (expiresAt: Date, now: Date) => number;
+/**
+ * Mint an owner token as Enphase's TEB-00060 shows: log in for a session id, then ask Entrez for the gateway's token.
+ * Two calls to Enphase's cloud; nothing is stored here.
+ */
+export declare function mintToken(options: {
+    username: string;
+    password: string;
+    serial: string;
+    fetch: typeof fetch;
+}): Promise<{
+    token: string;
+    expiresAt: Date;
+}>;
+/**
+ * A `fetch` for the gateway that skips certificate verification, for this gateway's requests only (Bun's `tls` option).
+ * The gateway's chain ends at Enphase's unpublished `root-a.PKI.CA`, and Bun 1.4.2 neither trusts a partial chain nor
+ * runs `checkServerIdentity` with verification off, so it cannot pin (measured). Reserve the gateway's IP. Node: see README.
+ */
+export declare function bunGatewayFetch(): typeof fetch;

package/dist/connectors/enphase/client.js

@@ -0,0 +1,173 @@
+import { z } from "zod";
+import { ConnectorError, fetchTimeout, getJson } from "../../connector.js";
+import { Login, Meters, Production, Readings, } from "./schemas.js";
+/** A failed Enphase call. `status` 401 means the token is wrong or expired. */
+export class EnphaseError extends ConnectorError {
+}
+/** A daily counter equal to the lifetime one is the software 8 bug seen on KO's gateway (D8.3.5528): not today's energy. */
+const today = (m) => m?.whToday !== undefined && m.whToday !== m.whLifetime
+    ? m.whToday
+    : undefined;
+const find = (list, type, measurementType) => list.find((m) => m.type === type &&
+    (measurementType === undefined || m.measurementType === measurementType));
+const live = (m) => m && (m.activeCount ?? 0) > 0 ? m : undefined;
+/**
+ * Map `/production.json` and `/ivp/meters` to a state. A meter counts only when `/ivp/meters` says
+ * "enabled" and its reading has `activeCount > 0` (KO's v1 code, pyenphase); else production falls back to the inverters.
+ */
+export function toState(production, meters) {
+    const p = Production.parse(production);
+    const enabled = new Set(Meters.parse(meters)
+        .filter((m) => m.state === "enabled")
+        .map((m) => m.measurementType));
+    const prodMeter = enabled.has("production")
+        ? live(find(p.production, "eim", "production"))
+        : undefined;
+    const inverters = find(p.production, "inverters");
+    const hasConsumption = enabled.has("total-consumption") || enabled.has("net-consumption");
+    const total = hasConsumption
+        ? live(find(p.consumption, "eim", "total-consumption"))
+        : undefined;
+    const net = hasConsumption
+        ? live(find(p.consumption, "eim", "net-consumption"))
+        : undefined;
+    const at = (prodMeter ?? inverters)?.readingTime;
+    const broken = [prodMeter, total].some((m) => m?.whToday !== undefined && m.whToday === m.whLifetime);
+    return {
+        productionW: (prodMeter ?? inverters)?.wNow,
+        productionWhToday: today(prodMeter),
+        productionWhLifetime: (prodMeter ?? inverters)?.whLifetime,
+        consumptionW: total?.wNow,
+        consumptionWhToday: today(total),
+        consumptionWhLifetime: total?.whLifetime,
+        ...(broken
+            ? {
+                anomaly: "the gateway's whToday equals its lifetime total; today is counted from the lifetime counter instead",
+            }
+            : {}),
+        netW: net?.wNow,
+        source: prodMeter ? "meter" : "inverters",
+        readingTime: at ? new Date(at * 1000).toISOString() : undefined,
+    };
+}
+/**
+ * Map `/ivp/meters` and `/ivp/meters/readings` to a state: ~100 ms on KO's gateway against 1–10 s for
+ * `/production.json` (measured, Bun 1.4.2). Consumption is production plus net import on a net-consumption meter,
+ * or read directly from a total-consumption meter (pyenphase's meter types). No daily totals here: callers count today.
+ */
+export function fromReadings(meters, readings) {
+    const enabled = Meters.parse(meters).filter((m) => m.state === "enabled");
+    const byEid = new Map(Readings.parse(readings).map((r) => [r.eid, r]));
+    const reading = (type) => byEid.get(enabled.find((m) => m.measurementType === type)?.eid ?? -1);
+    const prod = reading("production");
+    const net = reading("net-consumption");
+    const total = reading("total-consumption");
+    const pW = prod?.activePower;
+    const consumptionW = total?.activePower ??
+        (net?.activePower !== undefined && pW !== undefined
+            ? pW + net.activePower
+            : undefined);
+    const pLife = prod?.actEnergyDlvd;
+    const consumptionWhLifetime = total?.actEnergyDlvd ??
+        (pLife !== undefined &&
+            net?.actEnergyDlvd !== undefined &&
+            net.actEnergyRcvd !== undefined
+            ? pLife + net.actEnergyDlvd - net.actEnergyRcvd
+            : undefined);
+    const at = prod?.timestamp;
+    return {
+        productionW: pW,
+        productionWhLifetime: pLife,
+        consumptionW,
+        consumptionWhLifetime,
+        netW: net?.activePower ??
+            (consumptionW !== undefined && pW !== undefined
+                ? consumptionW - pW
+                : undefined),
+        source: "meter",
+        readingTime: at ? new Date(at * 1000).toISOString() : undefined,
+    };
+}
+/** The gateway's address as a bare host: a scheme prefix and a trailing slash, as people paste it, are dropped. */
+export const gatewayHost = (host) => host
+    .trim()
+    .replace(/^https?:\/\//i, "")
+    .replace(/\/+$/, "");
+/** A read-only client for the IQ Gateway's local API (software 7 and later). */
+export function enphaseClient(options) {
+    const headers = {
+        authorization: `Bearer ${options.token}`,
+        accept: "application/json",
+    };
+    // `host` is read at each call, so a getter follows a move.
+    const get = (path, signal) => getJson(options.fetch, `https://${gatewayHost(options.host)}${path}`, {
+        init: { headers },
+        signal,
+        error: EnphaseError,
+    });
+    return {
+        get,
+        /** Production, consumption and net now: the fast meter readings when a production meter is on, else `/production.json`. */
+        async read(signal) {
+            const meters = await get("/ivp/meters", signal);
+            const metered = Meters.parse(meters).some((m) => m.measurementType === "production" && m.state === "enabled");
+            return metered
+                ? fromReadings(meters, await get("/ivp/meters/readings", signal))
+                : toState(await get("/production.json?details=1", signal), meters);
+        },
+    };
+}
+/** When a JWT expires, from its `exp` claim. Throws on anything that is not a JWT. */
+export function tokenExpiry(token) {
+    const payload = token.split(".")[1];
+    if (!payload)
+        throw new EnphaseError("not a JWT");
+    const json = JSON.parse(atob(payload.replace(/-/g, "+").replace(/_/g, "/")));
+    const exp = z.object({ exp: z.number() }).parse(json).exp;
+    return new Date(exp * 1000);
+}
+/** Whole days until `expiresAt`, negative once expired. */
+export const daysLeft = (expiresAt, now) => Math.floor((expiresAt.getTime() - now.getTime()) / 86_400_000);
+/**
+ * Mint an owner token as Enphase's TEB-00060 shows: log in for a session id, then ask Entrez for the gateway's token.
+ * Two calls to Enphase's cloud; nothing is stored here.
+ */
+export async function mintToken(options) {
+    const form = new URLSearchParams({
+        "user[email]": options.username,
+        "user[password]": options.password,
+    });
+    const login = await fetchTimeout(options.fetch, "https://enlighten.enphaseenergy.com/login/login.json", { method: "POST", body: form });
+    const session = Login.safeParse(await login.json().catch(() => undefined));
+    if (!login.ok || !session.success)
+        throw new EnphaseError(`Enphase login failed (HTTP ${login.status})`, {
+            status: login.status,
+        });
+    const res = await fetchTimeout(options.fetch, "https://entrez.enphaseenergy.com/tokens", {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({
+            session_id: session.data.session_id,
+            serial_num: options.serial,
+            username: options.username,
+        }),
+    });
+    const token = (await res.text()).trim();
+    if (!res.ok)
+        throw new EnphaseError(`Entrez refused the token (HTTP ${res.status})`, {
+            status: res.status,
+        });
+    return { token, expiresAt: tokenExpiry(token) };
+}
+/**
+ * A `fetch` for the gateway that skips certificate verification, for this gateway's requests only (Bun's `tls` option).
+ * The gateway's chain ends at Enphase's unpublished `root-a.PKI.CA`, and Bun 1.4.2 neither trusts a partial chain nor
+ * runs `checkServerIdentity` with verification off, so it cannot pin (measured). Reserve the gateway's IP. Node: see README.
+ */
+export function bunGatewayFetch() {
+    const f = (input, init) => fetch(input, {
+        ...init,
+        tls: { rejectUnauthorized: false },
+    });
+    return f;
+}

package/dist/connectors/enphase/index.d.ts

@@ -0,0 +1,43 @@
+import { type Clock } from "../../clock.ts";
+import { z } from "zod";
+import { type Integration } from "../../home.ts";
+import { type Finder } from "../../discover.ts";
+import { type Manifest } from "../../manifest.ts";
+import { type EnphaseState } from "./client.ts";
+export { bunGatewayFetch, EnphaseError, type EnphaseOptions, type EnphaseState, enphaseClient, mintToken, tokenExpiry, } from "./client.ts";
+/** Poll every 60 s, as Home Assistant's enphase_envoy does. */
+export declare const POLL_MS = 60000;
+/** An IQ Gateway in a home config: its last known address, its serial (its identity), and the owner token's file. */
+export declare const configSchema: z.ZodObject<{
+    connector: z.ZodLiteral<"enphase">;
+    host: z.ZodString;
+    serial: z.ZodOptional<z.ZodString>;
+    token: z.ZodString;
+    marker: z.ZodOptional<z.ZodString>;
+    capacityW: z.ZodOptional<z.ZodNumber>;
+}, z.core.$loose>;
+/** Enphase settings: last known address, owner token, and optionally its serial and an mDNS discovery to find it again if it moves. `fetch` must accept the gateway's certificate: `bunGatewayFetch()` in Bun (see README). */
+export type EnphaseConfig = {
+    host: string;
+    token: string;
+    serial?: string;
+    find?: Finder;
+    fetch: typeof fetch;
+    clock?: Clock;
+    timeZone?: string;
+    seen?: (host: string) => void;
+    hostCached?: boolean;
+};
+/** What the snapshot holds: the latest reading, when it was taken, and the token's days left. */
+export type EnphaseSnapshot = EnphaseState & {
+    asOf: string;
+    tokenDaysLeft: number;
+    todaySince?: string;
+    productionWPeakToday?: number;
+    peakSince?: string;
+};
+/** The IQ Gateway as a home integration: one read now, then every 60 s. */
+export declare function enphase(config: EnphaseConfig): Integration<EnphaseSnapshot, "enphase">;
+/** "solar 2.1 kW, using 0.6 kW · token 300 days left". The login ask near the end is the integration's, in `detail`. */
+export declare function enphaseText(s: EnphaseSnapshot): string;
+export declare const manifest: Manifest<EnphaseSnapshot>;

package/dist/connectors/enphase/index.js

@@ -0,0 +1,174 @@
+import { localDay, realClock } from "../../clock.js";
+import { z } from "zod";
+import { filePath } from "../../home.js";
+import { lostDetail, relocator } from "../../discover.js";
+import { kw } from "../../manifest.js";
+import { poller } from "../../poll.js";
+import { daysLeft, enphaseClient, EnphaseError, gatewayHost, tokenExpiry, } from "./client.js";
+export { bunGatewayFetch, EnphaseError, enphaseClient, mintToken, tokenExpiry, } from "./client.js";
+/** Poll every 60 s, as Home Assistant's enphase_envoy does. */
+export const POLL_MS = 60_000;
+/** Warn when the token has fewer days left than this (Home Assistant's threshold). */
+const TOKEN_WARN_DAYS = 30;
+/** An IQ Gateway in a home config: its last known address, its serial (its identity), and the owner token's file. */
+export const configSchema = z.looseObject({
+    connector: z.literal("enphase"),
+    host: z.string().describe("the gateway's last known address"),
+    serial: z
+        .string()
+        .optional()
+        .describe("the gateway's serial, as mDNS `serialnum` (and /info) report it: its identity"),
+    token: filePath.describe("the owner token file: JSON with a `token` field (what `home enphase login` writes), or the bare token"),
+    marker: z
+        .string()
+        .startsWith("marker-")
+        .optional()
+        .describe("the plan's marker where the solar array is drawn, on the roof outside any room"),
+    capacityW: z
+        .number()
+        .positive()
+        .optional()
+        .describe("the array's rated size in watts, from the installer's paperwork; never guessed from the gateway"),
+});
+/** The IQ Gateway as a home integration: one read now, then every 60 s. */
+export function enphase(config) {
+    const clock = config.clock ?? realClock;
+    const where = relocator({
+        host: gatewayHost(config.host),
+        id: config.serial,
+        find: config.find,
+        clock,
+        cached: config.hostCached,
+    });
+    const client = enphaseClient({
+        ...config,
+        get host() {
+            return where.host();
+        },
+    });
+    const poll = poller(clock);
+    return {
+        name: "enphase",
+        refresh: () => (where.reset(), poll.nudge()),
+        async run(signal, update) {
+            const expiresAt = tokenExpiry(config.token); // a bad token fails this integration only
+            let last;
+            let day;
+            let moved; // kept in `detail` so a consumer can persist the new address
+            while (!signal.aborted) {
+                const now = new Date(clock.now());
+                const date = localDay(now.getTime(), config.timeZone); // the home's day, not the runtime's: a bot on a UTC box still resets at local midnight
+                const tokenDaysLeft = daysLeft(expiresAt, now);
+                // The one owner of the login ask: in `detail` whether the read works or not, so it shows while the gateway is unreachable too.
+                const warn = tokenDaysLeft < 0
+                    ? "token expired; run `home enphase login`"
+                    : tokenDaysLeft < TOKEN_WARN_DAYS
+                        ? `token expires in ${tokenDaysLeft} days; run \`home enphase login\``
+                        : undefined;
+                try {
+                    const s = await client.read(signal);
+                    if (day?.date !== date)
+                        day = {
+                            date,
+                            since: now.toISOString(),
+                            production: s.productionWhLifetime,
+                            consumption: s.consumptionWhLifetime,
+                        };
+                    if (s.productionW !== undefined)
+                        day.peakW = Math.max(day.peakW ?? s.productionW, s.productionW);
+                    const since = (lifetime, start) => lifetime !== undefined && start !== undefined
+                        ? lifetime - start
+                        : undefined;
+                    last = {
+                        ...s,
+                        productionWhToday: s.productionWhToday ??
+                            since(s.productionWhLifetime, day.production),
+                        consumptionWhToday: s.consumptionWhToday ??
+                            since(s.consumptionWhLifetime, day.consumption),
+                        todaySince: s.productionWhToday === undefined ? day.since : undefined,
+                        productionWPeakToday: day.peakW,
+                        peakSince: day.since,
+                        asOf: now.toISOString(),
+                        tokenDaysLeft,
+                    };
+                    where.ok();
+                    config.seen?.(where.host());
+                    update({
+                        status: "connected",
+                        detail: [moved, warn].filter(Boolean).join("; ") || undefined,
+                        anomaly: s.anomaly,
+                        state: last,
+                    });
+                }
+                catch (error) {
+                    if (signal.aborted)
+                        return; // stopped mid-read: not a failure
+                    if (error instanceof EnphaseError && error.status === 401)
+                        return update({
+                            status: "unavailable",
+                            detail: "the gateway rejected the token; run `home enphase login`",
+                            state: last,
+                        });
+                    const r = await where.failed(signal);
+                    if (r.moved) {
+                        moved = r.moved;
+                        continue; // read at the new address now; that read reports, with the move in `detail`
+                    }
+                    update({
+                        status: "disconnected",
+                        detail: [lostDetail(r, error), warn].filter(Boolean).join("; "),
+                        state: last,
+                    });
+                }
+                await poll.wait(POLL_MS, signal);
+            }
+        },
+    };
+}
+/** "solar 2.1 kW, using 0.6 kW · token 300 days left". The login ask near the end is the integration's, in `detail`. */
+export function enphaseText(s) {
+    const solar = s.productionW === undefined
+        ? ""
+        : [
+            `solar ${kw(s.productionW)}`,
+            s.consumptionW === undefined ? "" : `using ${kw(s.consumptionW)}`,
+        ]
+            .filter(Boolean)
+            .join(", ");
+    const token = s.tokenDaysLeft === undefined ? "" : `token ${s.tokenDaysLeft} days left`;
+    return [solar, token].filter(Boolean).join(" · ");
+}
+export const manifest = {
+    name: "enphase",
+    title: "Enphase IQ Gateway",
+    iotClass: "local_polling",
+    pollSeconds: POLL_MS / 1000,
+    access: "local HTTPS, owner token from `home enphase login`",
+    env: [
+        {
+            name: "IQ_GATEWAY_HOST",
+            example: "envoy.local",
+            what: "the IQ Gateway on the LAN (a scheme is tolerated)",
+        },
+        {
+            name: "IQ_GATEWAY_SERIAL_NUMBER",
+            example: "000000000000",
+            optional: true,
+            what: "for `home enphase login`; from the Enphase app: System > Devices > Gateway",
+        },
+        {
+            name: "ENPHASE_USERNAME",
+            example: "you@example.com",
+            optional: true,
+            what: "for `home enphase login`, once a year: the Enphase account",
+        },
+        {
+            name: "ENPHASE_PASSWORD",
+            example: "xxxxxxxx",
+            optional: true,
+            what: "for `home enphase login`; never stored, only sent to Enphase's login service",
+        },
+    ],
+    files: ["token"],
+    lines: ({ state }) => (state ? [enphaseText(state)] : []),
+};

package/dist/connectors/enphase/schemas.d.ts

@@ -0,0 +1,51 @@
+import { z } from "zod";
+/** One measurement in `/production.json`: an `inverters` total or an `eim` meter reading. */
+export declare const Measurement: z.ZodObject<{
+    type: z.ZodString;
+    measurementType: z.ZodOptional<z.ZodString>;
+    activeCount: z.ZodOptional<z.ZodNumber>;
+    wNow: z.ZodOptional<z.ZodNumber>;
+    whToday: z.ZodOptional<z.ZodNumber>;
+    whLifetime: z.ZodOptional<z.ZodNumber>;
+    readingTime: z.ZodOptional<z.ZodNumber>;
+}, z.core.$loose>;
+export type Measurement = z.infer<typeof Measurement>;
+/** `GET /production.json?details=1`. */
+export declare const Production: z.ZodObject<{
+    production: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        type: z.ZodString;
+        measurementType: z.ZodOptional<z.ZodString>;
+        activeCount: z.ZodOptional<z.ZodNumber>;
+        wNow: z.ZodOptional<z.ZodNumber>;
+        whToday: z.ZodOptional<z.ZodNumber>;
+        whLifetime: z.ZodOptional<z.ZodNumber>;
+        readingTime: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$loose>>>;
+    consumption: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        type: z.ZodString;
+        measurementType: z.ZodOptional<z.ZodString>;
+        activeCount: z.ZodOptional<z.ZodNumber>;
+        wNow: z.ZodOptional<z.ZodNumber>;
+        whToday: z.ZodOptional<z.ZodNumber>;
+        whLifetime: z.ZodOptional<z.ZodNumber>;
+        readingTime: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$loose>>>;
+}, z.core.$loose>;
+/** `GET /ivp/meters`: which current transformers exist and whether they are switched on. */
+export declare const Meters: z.ZodArray<z.ZodObject<{
+    eid: z.ZodOptional<z.ZodNumber>;
+    measurementType: z.ZodString;
+    state: z.ZodString;
+}, z.core.$loose>>;
+/** `GET /ivp/meters/readings`: one reading per meter, joined to `/ivp/meters` by `eid`. */
+export declare const Readings: z.ZodArray<z.ZodObject<{
+    eid: z.ZodNumber;
+    timestamp: z.ZodOptional<z.ZodNumber>;
+    activePower: z.ZodOptional<z.ZodNumber>;
+    actEnergyDlvd: z.ZodOptional<z.ZodNumber>;
+    actEnergyRcvd: z.ZodOptional<z.ZodNumber>;
+}, z.core.$loose>>;
+/** The JSON from Enphase's login: only the session id is used. */
+export declare const Login: z.ZodObject<{
+    session_id: z.ZodString;
+}, z.core.$loose>;