omni-notify-mcp 1.3.289 → 1.3.290

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omni-notify-mcp",
-  "version": "1.3.289",
+  "version": "1.3.290",
   "description": "Reach your AI agents from anywhere — and let them reach you. One stdio process serves the whole tool surface to Claude Code, GitHub Copilot Chat and Codex: desktop, Telegram, Slack, ntfy, Discord, Teams and SMS are configured in one file, and agents notify you when long work finishes or a decision is needed, ask you a question and wait for your answer, and receive and reply to the messages you send them — with Do Not Disturb and idle detection deciding what actually gets through.",
   "main": "dist/index.js",
   "type": "module",

package/dist/googlehome/foyer-client.js

@@ -1,210 +0,0 @@
-// The foyer-pa RPC client: builds positional `application/json+protobuf` arrays (via foyer-codec),
-// POSTs them to Google's Home Graph foyer endpoint, mints the bearer from the master token
-// (gpsoauth), and retries once on 401/403 while advancing scope negotiation.
-// Ported from coredevices/pebble-plugins `googlehome/src/foyer-client.ts` (which names the Kotlin
-// `FoyerRpcClient`/`FoyerAuthImpl` as its origin).
-import * as codec from './foyer-codec.js';
-import { FoyerAuthError } from './gpsoauth.js';
-const BASE = 'https://googlehomefoyer-pa.clients6.google.com/$rpc/google.internal.home.foyer.v1.';
-const HOME_CONTROL_SERVICE = 'HomeControlService';
-const STRUCTURES_SERVICE = 'StructuresService';
-const AUTOMATION_SERVICE = 'AutomationService';
-const CONTENT_TYPE = 'application/json+protobuf';
-// The (app, client_sig, scope) triple that yields a bearer foyer-pa accepts.
-const APP = 'com.google.android.apps.chromecast.app';
-const CLIENT_SIG = '24bb24c05e47e0aefa68a58a766179d9b613a600';
-const SCOPE_CANDIDATES = [
-    'oauth2:https://www.googleapis.com/auth/homegraph',
-    'oauth2:https://www.google.com/accounts/OAuthLogin',
-];
-/** A refusal the calling agent should read: no structure, a routine that cannot be started, … */
-export class GoogleHomeError extends Error {
-}
-export class FoyerHttpError extends GoogleHomeError {
-    status;
-    constructor(status, message) {
-        super(message);
-        this.status = status;
-    }
-}
-/** Strips a leading XSSI guard line (`)]}'`) some clients6 endpoints prepend. */
-export function stripXssiPrefix(body) {
-    const trimmed = body.replace(/^\s+/, '');
-    if (trimmed.startsWith(")]}'")) {
-        return trimmed.substring(4).replace(/^[\r\n]+/, '');
-    }
-    return body;
-}
-/** Mints + caches short-lived foyer bearers from the master token, with scope negotiation. */
-export class FoyerAuth {
-    masterToken;
-    androidId;
-    oauth;
-    scopes;
-    app;
-    clientSig;
-    fallbackTtlSeconds;
-    expirySkewSeconds;
-    nowEpochSeconds;
-    cachedToken = null;
-    expiresAtEpoch = 0;
-    scopeIndex = 0;
-    constructor(masterToken, androidId, oauth, scopes = SCOPE_CANDIDATES, app = APP, clientSig = CLIENT_SIG, fallbackTtlSeconds = 55 * 60, expirySkewSeconds = 60, nowEpochSeconds = () => Math.floor(Date.now() / 1000)) {
-        this.masterToken = masterToken;
-        this.androidId = androidId;
-        this.oauth = oauth;
-        this.scopes = scopes;
-        this.app = app;
-        this.clientSig = clientSig;
-        this.fallbackTtlSeconds = fallbackTtlSeconds;
-        this.expirySkewSeconds = expirySkewSeconds;
-        this.nowEpochSeconds = nowEpochSeconds;
-    }
-    async bearer() {
-        const now = this.nowEpochSeconds();
-        if (this.cachedToken != null && now < this.expiresAtEpoch)
-            return this.cachedToken;
-        return this.mint(now);
-    }
-    invalidate() {
-        this.cachedToken = null;
-        this.expiresAtEpoch = 0;
-        this.scopeIndex = this.scopes.length === 0 ? 0 : (this.scopeIndex + 1) % this.scopes.length;
-    }
-    async mint(now) {
-        if (this.scopes.length === 0)
-            throw new FoyerAuthError('no foyer scope candidates configured; cannot mint a bearer');
-        let lastError = null;
-        for (let offset = 0; offset < this.scopes.length; offset++) {
-            const i = (this.scopeIndex + offset) % this.scopes.length;
-            try {
-                const token = await this.oauth.getAuthToken(this.masterToken, this.androidId, this.scopes[i], this.app, this.clientSig);
-                this.scopeIndex = i;
-                this.cachedToken = token.auth;
-                this.expiresAtEpoch = this.deadlineFor(token.expiryEpochSeconds, now);
-                return token.auth;
-            }
-            catch (e) {
-                lastError = e instanceof Error ? e : new FoyerAuthError(String(e));
-            }
-        }
-        throw lastError instanceof Error ? lastError : new FoyerAuthError('no foyer scope candidates could be minted');
-    }
-    deadlineFor(expiryEpochSeconds, now) {
-        const cap = now + this.fallbackTtlSeconds;
-        const base = expiryEpochSeconds != null && expiryEpochSeconds > now ? Math.min(expiryEpochSeconds, cap) : cap;
-        return base - this.expirySkewSeconds;
-    }
-}
-export class FoyerClient {
-    auth;
-    constructor(auth) {
-        this.auth = auth;
-    }
-    // Reads ---------------------------------------------------------------------------------------
-    async fetchHomeGraph() {
-        const resp = await this.rpc(STRUCTURES_SERVICE, 'GetHomeGraph', []);
-        return codec.parseGetHomeGraph(resp);
-    }
-    async getHomeGraph() {
-        const g = await this.fetchHomeGraph();
-        return { homes: g.homes, devices: g.devices };
-    }
-    async listRooms() {
-        return (await this.fetchHomeGraph()).rooms;
-    }
-    async getTraits(deviceIds) {
-        if (deviceIds.length === 0)
-            return [];
-        const resp = await this.rpc(HOME_CONTROL_SERVICE, 'GetTraits', codec.buildGetTraitsRequest(deviceIds));
-        return codec.parseGetTraits(resp);
-    }
-    // Control (existing devices only; no add/delete) ----------------------------------------------
-    async setOnOff(deviceId, agentId, partnerDeviceId, on) {
-        return this.update(deviceId, codec.buildOnOff(deviceId, agentId, partnerDeviceId, on), on);
-    }
-    async setBrightness(deviceId, agentId, partnerDeviceId, pct) {
-        return this.update(deviceId, codec.buildBrightness(deviceId, agentId, partnerDeviceId, clamp(pct, 0, 100)));
-    }
-    async setColorTemperature(deviceId, agentId, partnerDeviceId, kelvin) {
-        return this.update(deviceId, codec.buildColorTemperature(deviceId, agentId, partnerDeviceId, kelvin));
-    }
-    async setVolume(deviceId, agentId, partnerDeviceId, pct) {
-        return this.update(deviceId, codec.buildVolume(deviceId, agentId, partnerDeviceId, clamp(pct, 0, 100)));
-    }
-    async setMuted(deviceId, agentId, partnerDeviceId, muted) {
-        return this.update(deviceId, codec.buildMuted(deviceId, agentId, partnerDeviceId, muted));
-    }
-    async listAutomations() {
-        const structureId = (await this.fetchHomeGraph()).homes[0]?.id;
-        if (structureId == null)
-            throw new GoogleHomeError('no home/structure found; cannot list routines');
-        const resp = await this.rpc(AUTOMATION_SERVICE, 'ListAutomations', codec.buildListAutomationsRequest(structureId));
-        return codec.parseListAutomations(resp);
-    }
-    async runAutomation(automation) {
-        if (!automation.manuallyRunnable) {
-            throw new GoogleHomeError(`routine '${automation.name}' is condition/schedule-triggered and can't be started on demand`);
-        }
-        const structureId = (await this.fetchHomeGraph()).homes[0]?.id;
-        if (structureId == null)
-            throw new GoogleHomeError('no home/structure found; cannot run a routine');
-        const resp = await this.rpc(AUTOMATION_SERVICE, 'ExecuteAutomation', codec.buildExecuteAutomationRequest(structureId, automation.id));
-        return Array.isArray(resp) && resp.length > 0 && String(resp[0]) === '1';
-    }
-    // Internals -----------------------------------------------------------------------------------
-    async update(deviceId, body, fallbackOnOff) {
-        const resp = await this.rpc(HOME_CONTROL_SERVICE, 'UpdateTraits', body);
-        const echoed = codec.parseGetTraits(resp).find((s) => s.id === deviceId);
-        if (echoed)
-            return echoed;
-        const readback = (await this.getTraits([deviceId])).find((s) => s.id === deviceId);
-        if (readback)
-            return readback;
-        return {
-            id: deviceId,
-            online: true,
-            onOff: fallbackOnOff ?? null,
-            brightnessPct: null,
-            colorTemperatureK: null,
-            volumePct: null,
-            muted: null,
-            locked: null,
-            jammed: null,
-            thermostatMode: null,
-            setpointC: null,
-            setpointF: null,
-            ambientC: null,
-            temperatureUnit: null,
-        };
-    }
-    /** POSTs body to `<BASE><service>/<method>`; on 401/403 invalidates + retries once. */
-    async rpc(service, method, body) {
-        const url = `${BASE}${service}/${method}`;
-        const bodyJson = JSON.stringify(body);
-        let response = await this.post(url, bodyJson, await this.auth.bearer());
-        if (response.status === 401 || response.status === 403) {
-            this.auth.invalidate();
-            response = await this.post(url, bodyJson, await this.auth.bearer());
-        }
-        if (response.status < 200 || response.status > 299) {
-            throw new FoyerHttpError(response.status, `google home ${service}/${method} -> HTTP ${response.status}: ${response.body.substring(0, 300)}`);
-        }
-        return JSON.parse(stripXssiPrefix(response.body));
-    }
-    async post(url, bodyJson, bearer) {
-        const resp = await fetch(url, {
-            method: 'POST',
-            headers: {
-                Authorization: `Bearer ${bearer}`,
-                'X-User-Agent': 'grpc-web-javascript/0.1',
-                'Content-Type': CONTENT_TYPE,
-            },
-            body: bodyJson,
-        });
-        return { status: resp.status, body: await resp.text() };
-    }
-}
-function clamp(n, lo, hi) {
-    return Math.max(lo, Math.min(hi, n));
-}

package/dist/googlehome/foyer-codec.js

@@ -1,318 +0,0 @@
-// Builds and parses the foyer-pa `application/json+protobuf` wire format.
-//
-// The service does NOT use JSON objects — every request/response body is a *positional* JSON array
-// where protobuf field numbers map to array indices (1-based, with `null` holes for absent fields).
-// Ported from coredevices/pebble-plugins `googlehome/src/foyer-codec.ts` (which names the Kotlin
-// `FoyerCodec` as its origin); the field indices were derived from live captures.
-//
-// Value encoding (the scalar wrapper `[i0,i1,i2,i3,…]`): a value sits at a type-specific index:
-//   - int / float  -> index 1: [null, <num>]
-//   - string / enum-> index 2: [null, null, "<str>"]
-//   - bool         -> index 3: [null, null, null, <0|1>]
-/** The type used for matching: user-assigned type when set, else hardware type. */
-export function effectiveType(d) {
-    return d.assignedType && d.assignedType.trim() !== '' ? d.assignedType : d.type;
-}
-// -------------------------------------------------------------------------------------------------
-// Null-safe positional-array accessors (out-of-range / wrong-typed slot -> null)
-// -------------------------------------------------------------------------------------------------
-function arr(x) {
-    return Array.isArray(x) ? x : null;
-}
-function at(a, i) {
-    return a != null && i >= 0 && i < a.length ? a[i] : null;
-}
-function str(x) {
-    return typeof x === 'string' ? x : null;
-}
-function boolAt(a, i) {
-    const e = at(a, i);
-    if (typeof e === 'boolean')
-        return e;
-    return e === 1;
-}
-function numAt(a, i) {
-    const e = at(a, i);
-    return typeof e === 'number' ? e : null;
-}
-function strAt(a, i) {
-    return str(at(a, i));
-}
-function arrAt(a, i) {
-    return arr(at(a, i));
-}
-// -------------------------------------------------------------------------------------------------
-// Scalar wrappers. In JS there is no int/float distinction, so intWrapper is just [null, n].
-// -------------------------------------------------------------------------------------------------
-function intWrapper(n) {
-    return [null, n];
-}
-function boolWrapper(b) {
-    return [null, null, null, b ? 1 : 0];
-}
-/** Flattens a trait body `[[fieldName,<wrapper>],…]` into a `fieldName -> wrapper` map. */
-function fieldWrappers(body) {
-    const out = new Map();
-    if (body == null)
-        return out;
-    for (const fieldEl of body) {
-        const field = arr(fieldEl);
-        const name = strAt(field, 0);
-        if (name == null)
-            continue;
-        out.set(name, arrAt(field, 1));
-    }
-    return out;
-}
-// -------------------------------------------------------------------------------------------------
-// GetTraits
-// -------------------------------------------------------------------------------------------------
-/** Request body for `HomeControlService/GetTraits`: `[[["id1"],["id2"],…]]`. */
-export function buildGetTraitsRequest(ids) {
-    return [ids.map((id) => [id])];
-}
-export function parseGetTraits(json) {
-    const results = arrAt(arr(json), 0);
-    if (results == null)
-        return [];
-    const out = [];
-    for (const result of results) {
-        const r = arr(result);
-        const id = strAt(arrAt(r, 0), 0);
-        if (id == null)
-            continue;
-        const traits = arrAt(r, 1);
-        const s = {
-            id,
-            online: false,
-            onOff: null,
-            brightnessPct: null,
-            colorTemperatureK: null,
-            volumePct: null,
-            muted: null,
-            locked: null,
-            jammed: null,
-            thermostatMode: null,
-            setpointC: null,
-            setpointF: null,
-            ambientC: null,
-            temperatureUnit: null,
-        };
-        if (traits != null) {
-            for (const entry of traits) {
-                const e = arr(entry);
-                const fields = fieldWrappers(arrAt(e, 1));
-                switch (strAt(e, 0)) {
-                    case 'deviceStatus':
-                        if (fields.has('online'))
-                            s.online = boolAt(fields.get('online') ?? null, 3);
-                        break;
-                    case 'onOff':
-                        if (fields.has('onOff'))
-                            s.onOff = boolAt(fields.get('onOff') ?? null, 3);
-                        break;
-                    case 'brightness':
-                        s.brightnessPct = numAt(fields.get('brightness') ?? null, 1);
-                        break;
-                    case 'color':
-                        s.colorTemperatureK = numAt(fields.get('colorTemperature') ?? null, 1);
-                        break;
-                    case 'volume':
-                        s.volumePct = numAt(fields.get('currentVolume') ?? null, 1);
-                        if (fields.has('isMuted'))
-                            s.muted = boolAt(fields.get('isMuted') ?? null, 3);
-                        break;
-                    case 'lockUnlock':
-                        if (fields.has('isLocked'))
-                            s.locked = boolAt(fields.get('isLocked') ?? null, 3);
-                        if (fields.has('isJammed'))
-                            s.jammed = boolAt(fields.get('isJammed') ?? null, 3);
-                        break;
-                    case 'temperatureSetting':
-                        s.thermostatMode = strAt(fields.get('mode') ?? null, 2);
-                        s.setpointC = numAt(fields.get('thermostatTemperatureSetpointC') ?? null, 1);
-                        s.setpointF = numAt(fields.get('thermostatTemperatureSetpointF') ?? null, 1);
-                        s.ambientC = numAt(fields.get('ambientAirTemperatureC') ?? null, 1);
-                        // temperatureUnit lives in the trait's params block (index 2), one array deeper.
-                        s.temperatureUnit = strAt(fieldWrappers(arrAt(arrAt(e, 2), 0)).get('temperatureUnit') ?? null, 2);
-                        break;
-                }
-            }
-        }
-        out.push(s);
-    }
-    return out;
-}
-// -------------------------------------------------------------------------------------------------
-// UpdateTraits (control)
-// -------------------------------------------------------------------------------------------------
-export function buildUpdate(deviceId, agentId, partnerDeviceId, traitName, fieldName, wrapper) {
-    const trait = [traitName, [[fieldName, wrapper]]];
-    const deviceKey = [deviceId, [agentId, partnerDeviceId]];
-    const command = [deviceKey, [trait]];
-    return [[command]];
-}
-export function buildOnOff(deviceId, agentId, partnerDeviceId, on) {
-    return buildUpdate(deviceId, agentId, partnerDeviceId, 'onOff', 'onOff', boolWrapper(on));
-}
-export function buildBrightness(deviceId, agentId, partnerDeviceId, pct) {
-    return buildUpdate(deviceId, agentId, partnerDeviceId, 'brightness', 'brightness', intWrapper(pct));
-}
-export function buildColorTemperature(deviceId, agentId, partnerDeviceId, kelvin) {
-    return buildUpdate(deviceId, agentId, partnerDeviceId, 'color', 'colorTemperature', intWrapper(kelvin));
-}
-export function buildVolume(deviceId, agentId, partnerDeviceId, pct) {
-    return buildUpdate(deviceId, agentId, partnerDeviceId, 'volume', 'currentVolume', intWrapper(pct));
-}
-export function buildMuted(deviceId, agentId, partnerDeviceId, muted) {
-    return buildUpdate(deviceId, agentId, partnerDeviceId, 'volume', 'isMuted', boolWrapper(muted));
-}
-// -------------------------------------------------------------------------------------------------
-// AutomationService (routines)
-// -------------------------------------------------------------------------------------------------
-/** `ListAutomations` request body: `[<structureId>]`. */
-export function buildListAutomationsRequest(structureId) {
-    return [structureId];
-}
-/** `ExecuteAutomation` request body: `[<structureId>, <automationId>, null, 2]`. */
-export function buildExecuteAutomationRequest(structureId, automationId) {
-    return [structureId, automationId, null, 2];
-}
-export function parseListAutomations(json) {
-    const list = arrAt(arr(json), 0);
-    if (list == null)
-        return [];
-    const out = [];
-    for (const recEl of list) {
-        const rec = arr(recEl);
-        const id = strAt(rec, 0);
-        const name = strAt(rec, 3);
-        if (id == null || name == null)
-            continue;
-        out.push({
-            id,
-            name,
-            manuallyRunnable: numAt(rec, 2) === 1,
-            starters: strAt(rec, 4),
-            actions: strAt(rec, 5),
-            triggerInput: strAt(rec, 10),
-        });
-    }
-    return out;
-}
-// -------------------------------------------------------------------------------------------------
-// Capability derivation
-// -------------------------------------------------------------------------------------------------
-export function deriveCapabilities(traits) {
-    const caps = new Set();
-    for (const raw of traits) {
-        const suffix = raw.split('.').pop()?.toLowerCase() ?? '';
-        switch (suffix) {
-            case 'onoff':
-                caps.add('on_off');
-                break;
-            case 'brightness':
-                caps.add('brightness');
-                break;
-            case 'colorsetting':
-                caps.add('color_temperature');
-                caps.add('color');
-                break;
-            case 'volume':
-                caps.add('volume');
-                break;
-            case 'lockunlock':
-                caps.add('lock');
-                break;
-            case 'temperaturesetting':
-            case 'temperaturecontrol':
-                caps.add('thermostat');
-                break;
-            case 'transportcontrol':
-            case 'mediastate':
-                caps.add('media_transport');
-                break;
-        }
-    }
-    return caps;
-}
-// -------------------------------------------------------------------------------------------------
-// GetHomeGraph (enumeration)
-// -------------------------------------------------------------------------------------------------
-export function parseGetHomeGraph(json) {
-    const homesArr = arrAt(arr(json), 1);
-    if (homesArr == null)
-        return { homes: [], devices: [], rooms: [] };
-    const homes = [];
-    const rooms = [];
-    const devices = [];
-    const deviceRoom = new Map();
-    for (const homeEl of homesArr) {
-        const home = arr(homeEl);
-        const homeId = strAt(home, 0);
-        if (homeId == null)
-            continue;
-        homes.push({ id: homeId, name: strAt(home, 1) ?? '' });
-        // Rooms: [5]
-        const roomsArr = arrAt(home, 5);
-        if (roomsArr != null) {
-            for (const roomEl of roomsArr) {
-                const room = arr(roomEl);
-                const roomId = strAt(room, 0);
-                if (roomId == null)
-                    continue;
-                const roomName = strAt(room, 2) ?? '';
-                const roomType = strAt(arrAt(room, 3), 0) ?? '';
-                const memberIds = [];
-                const members = arrAt(room, 4);
-                if (members != null) {
-                    for (const memberEl of members) {
-                        // member = [[deviceId,[agentId,partnerId]]]
-                        const devId = strAt(arrAt(arr(memberEl), 0), 0);
-                        if (devId == null)
-                            continue;
-                        memberIds.push(devId);
-                        deviceRoom.set(devId, roomName);
-                    }
-                }
-                rooms.push({ id: roomId, name: roomName, type: roomType, deviceIds: memberIds });
-            }
-        }
-        // Devices: [6]
-        const devsArr = arrAt(home, 6);
-        if (devsArr != null) {
-            for (const devEl of devsArr) {
-                const rec = arr(devEl);
-                const key = arrAt(rec, 0); // [deviceId,[agentId,partnerId]]
-                if (key == null)
-                    continue;
-                const devId = strAt(key, 0);
-                if (devId == null)
-                    continue;
-                const agentPair = arrAt(key, 1);
-                const agentId = strAt(agentPair, 0);
-                const partnerDeviceId = strAt(agentPair, 1);
-                const name = strAt(rec, 3) ?? '';
-                const type = strAt(rec, 5) ?? '';
-                // Field [20] is the USER-ASSIGNED device type; it overrides hardware type [5] for intent.
-                const assignedType = strAt(arrAt(rec, 20), 0);
-                const traitsArr = arrAt(rec, 6);
-                const traits = traitsArr == null ? [] : traitsArr.map((t) => str(t)).filter((t) => t != null);
-                devices.push({
-                    id: devId,
-                    name,
-                    type,
-                    assignedType,
-                    traits,
-                    roomName: deviceRoom.get(devId) ?? null,
-                    agentId,
-                    partnerDeviceId,
-                    capabilities: deriveCapabilities(traits),
-                });
-            }
-        }
-    }
-    // Room membership can appear after a device record within the same home; stamp again.
-    const stamped = devices.map((d) => d.roomName == null ? { ...d, roomName: deviceRoom.get(d.id) ?? null } : d);
-    return { homes, devices: stamped, rooms };
-}

package/dist/googlehome/gpsoauth.js

@@ -1,119 +0,0 @@
-// gpsoauth against `https://android.clients.google.com/auth` — the sign-in the Google Home Android
-// app itself uses. Ported from coredevices/pebble-plugins `googlehome/src/gpsoauth.ts` (which names
-// the Kotlin `GpsOAuthCodec`/`GpsOAuthClient` as its origin); the foyer Home Assistant integration
-// carries the same protocol in `custom_components/googlehome_foyer/api.py`.
-//
-// The endpoint speaks a picky, non-JSON protocol:
-//   - Request body is `application/x-www-form-urlencoded`.
-//   - Response is newline-delimited `Key=Value` text (parsed by parseAuthResponse).
-// `EncryptedPasswd` carries the master token verbatim (nothing is encrypted).
-export const AUTH_URL = 'https://android.clients.google.com/auth';
-export const DEFAULT_ANDROID_ID = '0123456789abcdef';
-// The master token identifies the account, so any syntactically-valid Email works.
-export const PLACEHOLDER_EMAIL = 'owner@example.com';
-export const PLAY_SERVICES_VERSION = '240913000';
-export const AC2DM_SERVICE = 'ac2dm';
-// GMS core signing cert used for the ac2dm master-token exchange (not the per-app chromecast sig).
-export const GMS_CLIENT_SIG = '38918a453d07199354f8b19af05ec6562ced5788';
-export class FoyerAuthError extends Error {
-}
-/** ac2dm oauth_token -> master token exchange form. androidId must match the later getAuthToken. */
-export function buildExchangeForm(oauthToken, androidId, email = PLACEHOLDER_EMAIL) {
-    return {
-        accountType: 'HOSTED_OR_GOOGLE',
-        Email: email,
-        has_permission: '1',
-        add_account: '1',
-        ACCESS_TOKEN: '1',
-        Token: oauthToken,
-        service: AC2DM_SERVICE,
-        source: 'android',
-        androidId,
-        device_country: 'us',
-        operatorCountry: 'us',
-        lang: 'en',
-        sdk_version: '17',
-        google_play_services_version: PLAY_SERVICES_VERSION,
-        client_sig: GMS_CLIENT_SIG,
-        callerSig: GMS_CLIENT_SIG,
-        droidguard_results: 'dummy123',
-    };
-}
-/** getAuthToken form: masterToken -> a short-lived bearer scoped to `service`. */
-export function buildAuthTokenForm(masterToken, androidId, service, app, clientSig, email = PLACEHOLDER_EMAIL) {
-    return {
-        accountType: 'HOSTED_OR_GOOGLE',
-        Email: email,
-        has_permission: '1',
-        // Despite the name, this carries the master token verbatim (no encryption).
-        EncryptedPasswd: masterToken,
-        service,
-        source: 'android',
-        androidId,
-        app,
-        client_sig: clientSig,
-        device_country: 'us',
-        operatorCountry: 'us',
-        lang: 'en',
-        sdk_version: '17',
-        google_play_services_version: PLAY_SERVICES_VERSION,
-    };
-}
-/** Parses the `Key=Value` newline-delimited auth response. Values may themselves contain `=`. */
-export function parseAuthResponse(body) {
-    const out = {};
-    for (const rawLine of body.split('\n')) {
-        const line = rawLine.trim();
-        if (line === '')
-            continue;
-        const idx = line.indexOf('=');
-        if (idx < 0)
-            continue;
-        out[line.substring(0, idx)] = line.substring(idx + 1);
-    }
-    return out;
-}
-/** `application/x-www-form-urlencoded` body. */
-export function formEncode(form) {
-    return Object.entries(form)
-        .map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`)
-        .join('&');
-}
-/** The two gpsoauth exchanges. Both carry credential material in the body and never log it. */
-export class GpsOAuth {
-    async exchangeOAuthToken(oauthToken, androidId = DEFAULT_ANDROID_ID) {
-        const parsed = await this.post(buildExchangeForm(oauthToken, androidId));
-        const token = parsed['Token'];
-        if (token == null) {
-            throw new FoyerAuthError(`google sign-in rejected the one-time token: ${parsed['Error'] ?? 'no Token in response'}`);
-        }
-        const email = parsed['Email'];
-        return { masterToken: token, email: email != null && email !== '' ? email : null };
-    }
-    async getAuthToken(masterToken, androidId, service, app, clientSig, email = PLACEHOLDER_EMAIL) {
-        const parsed = await this.post(buildAuthTokenForm(masterToken, androidId, service, app, clientSig, email));
-        const auth = parsed['Auth'];
-        if (auth == null) {
-            throw new FoyerAuthError(`google sign-in could not mint a bearer: ${parsed['Error'] ?? 'unknown'}`);
-        }
-        const expiry = parsed['Expiry'] != null ? Number.parseInt(parsed['Expiry'], 10) : NaN;
-        return { auth, expiryEpochSeconds: Number.isFinite(expiry) ? expiry : null };
-    }
-    async post(form) {
-        const resp = await fetch(AUTH_URL, {
-            method: 'POST',
-            headers: {
-                'User-Agent': 'GoogleAuth/1.4',
-                'Accept-Encoding': 'identity',
-                'Content-Type': 'application/x-www-form-urlencoded',
-            },
-            body: formEncode(form),
-        });
-        // A parsed reply is returned for 2xx AND for 4xx, where Google reports rejected credentials
-        // (e.g. Error=BadAuthentication); only a server-side failure (429/5xx) is retried upstream.
-        if (resp.status === 429 || resp.status >= 500) {
-            throw new FoyerAuthError(`google sign-in: HTTP ${resp.status}`);
-        }
-        return parseAuthResponse(await resp.text());
-    }
-}

package/dist/googlehome/index.js

@@ -1,267 +0,0 @@
-// Google Home over MCP: reads and controls Meni's Google Home devices and runs his routines, on the
-// SAME agent-gateway door (`/mcp`, port 7470) and behind the same bearer/passkey/OAuth auth as the
-// `agent_*` tools — so ChatGPT's voice mode drives them exactly as it drives the agent sessions.
-//
-// The device/room/routine layer is ported from coredevices/pebble-plugins `googlehome/src/server.ts`
-// (its Kotlin `GoogleHomeMcpServer` + `DeviceResolver` origin). Lock/unlock and the passcode are
-// deliberately ABSENT: an MCP door that unlocks the house is Meni's decision, never a default.
-//
-// The device list, the command codec and the sign-in all ride Google's PRIVATE app API (the foyer
-// interface), reverse engineered and undocumented; Google can change it without notice, and no
-// documented Google path covers non-Nest lights, plugs or speakers.
-import { z } from "zod";
-import { effectiveType } from "./foyer-codec.js";
-import { FoyerAuth, FoyerClient, GoogleHomeError } from "./foyer-client.js";
-import { FoyerAuthError, GpsOAuth } from "./gpsoauth.js";
-import { googleHomeCredential } from "../notify.js";
-/** Every tool's answer is JSON text, as the gateway's `agent_*` tools do. */
-const answer = (value) => ({ content: [{ type: "text", text: JSON.stringify(value, null, 2) }] });
-/** A refused act (a known Google Home failure: not signed in, no device matched, an API/HTTP error)
- * is the tool's own error result carrying its reason; anything else is a bug and rethrows to the SDK,
- * which answers a protocol error rather than a mask. */
-function act(run) {
-    return Promise.resolve()
-        .then(run)
-        .then(answer)
-        .catch((err) => {
-        if (err instanceof GoogleHomeError || err instanceof FoyerAuthError) {
-            return { content: [{ type: "text", text: err.message }], isError: true };
-        }
-        throw err;
-    });
-}
-const NOT_SIGNED_IN = "Google Home is not signed in on this machine. Run `node scripts/googlehome-signin.mjs` once in a " +
-    "terminal and sign in with the Google account that owns your home; the one-time token is exchanged " +
-    "for a long-lived master token and stored in the notify secrets file.";
-/** The sign-in secret resolved fresh: a sign-in that just happened is seen by the next tool call, no restart. */
-function client() {
-    const cred = googleHomeCredential();
-    if (cred == null)
-        throw new GoogleHomeError(NOT_SIGNED_IN);
-    return new FoyerClient(new FoyerAuth(cred.masterToken, cred.androidId, new GpsOAuth()));
-}
-function norm(s) {
-    const t = s?.trim().toLowerCase();
-    return t && t !== "" ? t : null;
-}
-function typeMatches(deviceType, want) {
-    const suffix = deviceType.split(".").pop()?.toLowerCase() ?? "";
-    return suffix === want || deviceType.toLowerCase() === want;
-}
-/**
- * Natural requests often append a device kind to a custom Google Home name: "driveway lights" for a
- * light-capable device actually named "driveway". Only leading articles and trailing kind words that
- * fit the action's required capability are stripped — deliberately no general fuzzy matching, which
- * could control the wrong device.
- */
-const SELECTOR_KIND_WORDS = {
-    on_off: new Set(["light", "lights", "lamp", "lamps", "bulb", "bulbs", "switch", "switches", "outlet", "outlets", "plug", "plugs", "speaker", "speakers"]),
-    brightness: new Set(["light", "lights", "lamp", "lamps", "bulb", "bulbs"]),
-    color_temperature: new Set(["light", "lights", "lamp", "lamps", "bulb", "bulbs"]),
-    color: new Set(["light", "lights", "lamp", "lamps", "bulb", "bulbs"]),
-    volume: new Set(["speaker", "speakers"]),
-    lock: new Set(["lock", "locks"]),
-    thermostat: new Set(["thermostat", "thermostats"]),
-    media_transport: new Set(["speaker", "speakers", "player", "players", "tv", "tvs", "display", "displays"]),
-};
-const SELECTOR_LEADING_WORDS = new Set(["the", "my"]);
-function selectorNameAliases(wantName, requiredCap) {
-    const original = wantName.split(/\s+/).filter((word) => word !== "");
-    if (original.length < 2)
-        return [];
-    const aliases = [];
-    const kindWords = SELECTOR_KIND_WORDS[requiredCap];
-    const suffixStripped = [...original];
-    while (suffixStripped.length > 1 && kindWords.has(suffixStripped[suffixStripped.length - 1])) {
-        suffixStripped.pop();
-        aliases.push(suffixStripped.join(" "));
-    }
-    const leadingStripped = [...original];
-    while (leadingStripped.length > 1 && SELECTOR_LEADING_WORDS.has(leadingStripped[0])) {
-        leadingStripped.shift();
-        aliases.push(leadingStripped.join(" "));
-    }
-    while (leadingStripped.length > 1 && kindWords.has(leadingStripped[leadingStripped.length - 1])) {
-        leadingStripped.pop();
-        aliases.push(leadingStripped.join(" "));
-    }
-    return [
-        ...new Set(aliases.filter((alias) => {
-            const words = alias.split(/\s+/);
-            return alias !== "" && alias !== wantName && words.some((word) => !SELECTOR_LEADING_WORDS.has(word) && !kindWords.has(word));
-        })),
-    ];
-}
-function matchExact(devices, wantedNames) {
-    for (const wanted of wantedNames) {
-        const exact = devices.filter((device) => device.name.trim().toLowerCase() === wanted);
-        if (exact.length > 0)
-            return exact;
-    }
-    return [];
-}
-function matchSubstring(devices, wantedNames) {
-    for (const wanted of wantedNames) {
-        const substring = devices.filter((device) => device.name.trim().toLowerCase().includes(wanted));
-        if (substring.length > 0)
-            return substring;
-    }
-    return [];
-}
-function describeSelector(sel) {
-    const parts = [
-        sel.name && sel.name.trim() !== "" ? `name="${sel.name}"` : null,
-        sel.room && sel.room.trim() !== "" ? `room="${sel.room}"` : null,
-        sel.type && sel.type.trim() !== "" ? `type="${sel.type}"` : null,
-    ].filter((p) => p != null);
-    return parts.length === 0 ? "(no filters)" : parts.join(", ");
-}
-function nearNames(sel, devices, limit = 12) {
-    const wantRoom = norm(sel.room);
-    const wantType = norm(sel.type);
-    const wantNameTokens = (norm(sel.name) ?? "").split(/\s+/).filter((t) => t !== "");
-    const relaxed = devices.filter((d) => (wantRoom != null && d.roomName?.trim().toLowerCase().includes(wantRoom) === true) ||
-        (wantType != null && typeMatches(effectiveType(d), wantType)) ||
-        (wantNameTokens.length > 0 && wantNameTokens.some((t) => d.name.toLowerCase().includes(t))));
-    const pool = relaxed.length > 0 ? relaxed : devices;
-    return [...new Set(pool.map((d) => d.name))].slice(0, limit);
-}
-async function resolve(foyer, sel, requiredCap) {
-    if (norm(sel.name) == null && norm(sel.room) == null && norm(sel.type) == null) {
-        throw new GoogleHomeError('Provide at least one selector: name, room, and/or type (e.g. type="light" for all lights, ' +
-            'or room="kitchen" + type="light" for the kitchen lights).');
-    }
-    const { devices } = await foyer.getHomeGraph();
-    const wantName = norm(sel.name);
-    const wantRoom = norm(sel.room);
-    const wantType = norm(sel.type);
-    // Room matches EXACTLY; type matches the type suffix. AND-combined.
-    const scoped = devices.filter((d) => (wantRoom == null || d.roomName?.trim().toLowerCase() === wantRoom) &&
-        (wantType == null || typeMatches(effectiveType(d), wantType)));
-    let matches;
-    if (wantName == null) {
-        matches = scoped;
-    }
-    else {
-        matches = matchExact(scoped, [wantName]);
-        if (matches.length === 0) {
-            const aliases = selectorNameAliases(wantName, requiredCap);
-            matches = matchExact(scoped, aliases);
-            if (matches.length === 0) {
-                const capable = scoped.filter((device) => device.capabilities.has(requiredCap));
-                matches = matchSubstring(capable, aliases);
-            }
-            if (matches.length === 0)
-                matches = matchSubstring(scoped, [wantName]);
-        }
-    }
-    if (matches.length === 0) {
-        const near = nearNames(sel, devices);
-        const known = near.length === 0 ? "No devices are known." : `Closest known devices: ${near.map((n) => `"${n}"`).join(", ")}.`;
-        throw new GoogleHomeError(`No devices matched selector ${describeSelector(sel)}. ${known} ` +
-            "Use googlehome_list_devices to see every device with its room, type and capabilities.");
-    }
-    return matches;
-}
-// -------------------------------------------------------------------------------------------------
-// JSON projection
-// -------------------------------------------------------------------------------------------------
-function stateToJson(s) {
-    return {
-        id: s.id,
-        online: s.online,
-        on_off: s.onOff,
-        brightness_pct: s.brightnessPct,
-        color_temperature_k: s.colorTemperatureK,
-        volume_pct: s.volumePct,
-        muted: s.muted,
-    };
-}
-function deviceToJson(d, state) {
-    const et = effectiveType(d);
-    const out = { id: d.id, name: d.name, type: et };
-    if (d.assignedType != null && d.assignedType !== d.type)
-        out["hardware_type"] = d.type;
-    out["capabilities"] = [...d.capabilities];
-    out["room_name"] = d.roomName;
-    out["online"] = state?.online ?? null;
-    out["on_off"] = state?.onOff ?? null;
-    return out;
-}
-function resultRow(id, name, ok, state, error) {
-    const row = { id, name, ok };
-    if (state)
-        row["state"] = stateToJson(state);
-    if (error)
-        row["error"] = error;
-    return row;
-}
-// -------------------------------------------------------------------------------------------------
-// Control plumbing
-// -------------------------------------------------------------------------------------------------
-const agent = (d) => d.agentId ?? "";
-const partner = (d) => d.partnerDeviceId ?? "";
-async function applyControl(args, requiredCap, capLabel, action) {
-    const foyer = client();
-    const devices = await resolve(foyer, args, requiredCap);
-    const rows = [];
-    for (const d of devices) {
-        if (!d.capabilities.has(requiredCap)) {
-            rows.push(resultRow(d.id, d.name, false, undefined, `skipped: does not support ${capLabel}`));
-            continue;
-        }
-        try {
-            rows.push(resultRow(d.id, d.name, true, await action(foyer, d)));
-        }
-        catch (e) {
-            rows.push(resultRow(d.id, d.name, false, undefined, e instanceof Error ? e.message : String(e)));
-        }
-    }
-    return { matched: devices.length, results: rows };
-}
-const SELECTOR_KEYS = {
-    name: z.string().optional().describe('Device name to match (exact preferred, then case-insensitive substring); a trailing kind like "lights" is tolerated.'),
-    room: z.string().optional().describe('Room name to match (case-insensitive substring), e.g. "kitchen".'),
-    type: z.string().optional().describe("Device type suffix: light, speaker, outlet, switch, thermostat."),
-};
-function selectorFrom(a) {
-    return { name: a.name, room: a.room, type: a.type };
-}
-// -------------------------------------------------------------------------------------------------
-// Tool registration
-// -------------------------------------------------------------------------------------------------
-/**
- * Register the Google Home tools on the agent-gateway MCP server, beside the `agent_*` tools.
- * Read tools enumerate and read; control tools take a selector, apply to EVERY capable match, and
- * return per-device {id,name,ok,state|error}. There is no add/delete surface.
- */
-export function registerGoogleHomeTools(server) {
-    server.tool("googlehome_list_devices", "List every Google Home device across all homes with its room, type, capabilities (on_off, brightness, color_temperature, color, volume, thermostat, media_transport) and live online/on-off state. Read-only. Use it to see the names/rooms/types the control tools' selectors target.", {}, () => act(async () => {
-        const foyer = client();
-        const { devices } = await foyer.getHomeGraph();
-        let stateById = new Map();
-        if (devices.length > 0) {
-            stateById = new Map((await foyer.getTraits(devices.map((d) => d.id))).map((s) => [s.id, s]));
-        }
-        return devices.map((d) => deviceToJson(d, stateById.get(d.id)));
-    }));
-    server.tool("googlehome_get_device_state", "Get the live state (online, on/off, brightness, color temperature, volume, mute) for one or more devices by id. Read-only.", { device_ids: z.array(z.string()).describe("Device ids to read state for") }, ({ device_ids }) => act(async () => (await client().getTraits(device_ids)).map(stateToJson)));
-    server.tool("googlehome_turn_on", 'Turn on devices. Scope with name/room/type: name="Corner Lamp" for one, type="light" for all lights, room="kitchen" + type="light" for the kitchen lights. Applies to every matching on/off device.', SELECTOR_KEYS, (a) => act(() => applyControl(selectorFrom(a), "on_off", "on/off", (f, d) => f.setOnOff(d.id, agent(d), partner(d), true))));
-    server.tool("googlehome_turn_off", 'Turn off devices. Scope with name/room/type, e.g. type="light" for all lights.', SELECTOR_KEYS, (a) => act(() => applyControl(selectorFrom(a), "on_off", "on/off", (f, d) => f.setOnOff(d.id, agent(d), partner(d), false))));
-    server.tool("googlehome_set_brightness", 'Set brightness (0-100%) on lights. Scope with name/room/type, e.g. room="bedroom" + type="light", brightness_pct=40.', { ...SELECTOR_KEYS, brightness_pct: z.number().describe("Brightness 0-100 (clamped)") }, (a) => act(() => applyControl(selectorFrom(a), "brightness", "brightness", (f, d) => f.setBrightness(d.id, agent(d), partner(d), a.brightness_pct))));
-    server.tool("googlehome_set_color_temperature", "Set white color temperature in Kelvin (warm ~2700, cool ~6500) on color-temperature lights. Scope with name/room/type, e.g. name=\"Desk Light\", kelvin=4000.", { ...SELECTOR_KEYS, kelvin: z.number().describe("Color temperature in Kelvin, e.g. 2700-6500") }, (a) => act(() => applyControl(selectorFrom(a), "color_temperature", "color temperature", (f, d) => f.setColorTemperature(d.id, agent(d), partner(d), a.kelvin))));
-    server.tool("googlehome_set_volume", 'Set volume (0-100%) on speakers. Scope with name/room/type, e.g. name="Living Room Speaker" volume_pct=30.', { ...SELECTOR_KEYS, volume_pct: z.number().describe("Volume 0-100 (clamped)") }, (a) => act(() => applyControl(selectorFrom(a), "volume", "volume", (f, d) => f.setVolume(d.id, agent(d), partner(d), a.volume_pct))));
-    server.tool("googlehome_set_muted", 'Mute or unmute speakers. Scope with name/room/type, e.g. type="speaker" muted=true.', { ...SELECTOR_KEYS, muted: z.boolean().describe("true = muted, false = unmuted") }, (a) => act(() => applyControl(selectorFrom(a), "volume", "volume/mute", (f, d) => f.setMuted(d.id, agent(d), partner(d), a.muted))));
-    server.tool("googlehome_list_routines", "List the home's Google Home routines: name and whether it can be started on demand (manually_runnable). Read-only. Use before googlehome_run_routine.", {}, () => act(async () => (await client().listAutomations()).map((r) => ({ id: r.id, name: r.name, manually_runnable: r.manuallyRunnable }))));
-    server.tool("googlehome_run_routine", 'Run a Google Home routine by name, e.g. name="Movie Night". Only manually-runnable routines can be started on demand. This runs the routine\'s EXISTING actions; it never creates or deletes anything.', { name: z.string().describe("The routine's name (case-insensitive; exact preferred)") }, ({ name }) => act(async () => {
-        const wanted = name.trim();
-        const foyer = client();
-        const routines = await foyer.listAutomations();
-        const lower = wanted.toLowerCase();
-        const match = routines.find((r) => r.name.trim().toLowerCase() === lower) ?? routines.find((r) => r.name.trim().toLowerCase().includes(lower));
-        if (match == null) {
-            throw new GoogleHomeError(`No routine named '${wanted}'. Available: ${routines.map((r) => `"${r.name}"`).join(", ")}`);
-        }
-        return { name: match.name, id: match.id, ok: await foyer.runAutomation(match) };
-    }));
-}