omni-notify-mcp 1.3.306 → 1.3.308

package/dist/daemon.js

@@ -13,8 +13,9 @@ import { spawn } from "child_process";
 import { existsSync, readFileSync, renameSync, writeFileSync, mkdirSync } from "fs";
 import { join } from "path";
 import { fileURLToPath } from "url";
-import { ALWAYS_ON_PATH, CONFIG_DIR, PACKAGE_VERSION, startNotifyServer } from "./notify.js";
+import { ALWAYS_ON_PATH, CONFIG_DIR, PACKAGE_VERSION, startNotifyServer, yieldGateway } from "./notify.js";
 import { startNotifyDoor } from "./gateway/notifyDoor.js";
+import { announceTakeover } from "./shared/webhost/originHandover.js";
 import { TunnelRunner } from "./gateway/tunnel.js";
 const HEARTBEAT_MS = 10_000;
 function beat(pid = process.pid) {
@@ -70,14 +71,22 @@ if (stoppedByHand()) {
     console.log("[BOOT] BullseyeNotify always-on — a Stop was pressed on this machine; nothing started, and nothing beats until Start is pressed in the panel.");
     process.exit(0);
 }
+// The shared hand-over (src/shared/webhost/originHandover.js ensureResidentDoor) puts a later release on the chat door: the new build is started with --takeover over an IPC channel, says it waits, and binds once this build lets the door go.
+const takeover = process.argv.includes("--takeover");
+/** Whether this process writes the heartbeat: the next release only from the moment it holds the chat door, so a takeover that never lands leaves the serving build's beat alone; and a build that let the door go no longer, so the release that took it is the one beat. */
+let beating = !takeover;
 // The server's own timers are unref'd because a bridge lives as long as its stdin; this process lives until it is stopped.
-beat();
-/** Each beat reads the Stop first: a press in a window that may not end this process — the boot task's, in session 0 — stops it all the same, within one beat. */
+if (beating)
+    beat();
+/** Each tick reads the Stop first, beating or not: a press in a window that may not end this process — the boot task's, in session 0, or one still draining its gateway after a hand-over — stops it all the same, within one tick. */
 const beatTimer = setInterval(() => {
     if (stoppedByHand())
         process.exit(0);
-    beat();
+    if (beating)
+        beat();
 }, HEARTBEAT_MS);
+/** Settles once the chat door has closed after the next release's `POST /shutdown`; set only then, when that release is already running and waiting for the port, so this process starts no successor. */
+let handedOver;
 // Only the daemon that owns the gateway port runs the connector and publishes its state: a dormant one has nothing for it to reach.
 const tunnel = new TunnelRunner();
 startNotifyServer({
@@ -86,9 +95,20 @@ startNotifyServer({
         tunnel.beat(port);
         setInterval(() => tunnel.beat(port), HEARTBEAT_MS);
     },
-    onSuperseded: replaceWithInstalledBuild,
+    onSuperseded: () => (handedOver === undefined ? replaceWithInstalledBuild() : void handedOver.then(() => process.exit(0))),
+});
+startNotifyDoor(() => { beating = true; beat(); }, undefined, {
+    version: PACKAGE_VERSION,
+    takeover,
+    onShutdown: (closed) => {
+        beating = false;
+        handedOver = closed;
+        yieldGateway();
+    },
+    onTakeoverGaveUp: () => process.exit(1),
 });
-startNotifyDoor(() => { });
+if (takeover)
+    announceTakeover();
 for (const signal of ["SIGINT", "SIGTERM", "SIGHUP"]) {
     process.on(signal, () => process.exit(0));
 }

package/dist/gateway/notifyDoor.js

@@ -23,11 +23,14 @@
 import { createServer, request as httpRequest } from "http";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import { createMcpServer, sessionIdentity } from "../notify.js";
+import { answerShutdown, healthBody, TAKEOVER_BIND } from "../shared/webhost/originHandover.js";
 /** BN's own port block: 7470 is the gateway, so the chat tools take the next free one. */
 // GATE: the door's port may be moved ONLY under the test gate, so a suite drives a real always-on process on a port it owns; without the gate it is 7475 and no environment can redirect it. vscode-extension/alwaysOn.js probes the same rule.
 export const NOTIFY_DOOR_PORT = process.env.NOTIFY_MCP_TEST_ENDPOINTS === "1" && Number(process.env.NOTIFY_DOOR_PORT) > 0 ? Number(process.env.NOTIFY_DOOR_PORT) : 7475;
 export const NOTIFY_DOOR_PATH = "/mcp";
 const RETRY_MS = 5_000;
+/** The name the always-on process answers `/health` with: the `server` the boot task's supervisor hands BN's port over by (vscode-extension/originSupervisor.js ORIGINS). */
+export const NOTIFY_SERVER = "bullseye-notify";
 function headerOf(req, name) {
     const value = req.headers[name];
     const one = Array.isArray(value) ? value[0] : value;
@@ -76,18 +79,32 @@ function notifyDoorAnswers(port) {
  * stated, because then notify's chat tools are unreachable machine-wide and nothing else would say so.
  * Never rejects.
  */
-export function startNotifyDoor(onBound, port = NOTIFY_DOOR_PORT) {
+export function startNotifyDoor(onBound, port = NOTIFY_DOOR_PORT, resident) {
     let bound = false;
     let attempting = false;
+    let stopping = false;
     let lastCause = "";
     let listener = null;
+    const giveUpAt = Date.now() + TAKEOVER_BIND.giveUpMs;
     const say = (line) => { process.stderr.write(`[notify] ${line}\n`); };
     const attempt = () => {
-        if (bound || attempting)
+        if (bound || attempting || stopping)
             return;
         attempting = true;
         const server = listener = createServer((req, res) => {
             const path = new URL(req.url ?? "/", "http://door").pathname;
+            if (resident !== undefined && path === "/health") {
+                res.writeHead(200, { "content-type": "application/json" });
+                res.end(healthBody(NOTIFY_SERVER, port, resident.version));
+                return;
+            }
+            if (resident !== undefined && answerShutdown(req, res, server, NOTIFY_SERVER, port, resident.version, (closed) => {
+                stopping = true;
+                bound = false;
+                say(`the next release asked for the chat door on ${port}; build ${resident.version} lets it go`);
+                resident.onShutdown(closed);
+            }))
+                return;
             if (path !== NOTIFY_DOOR_PATH) {
                 refuse(res, 404, `the notify MCP door answers on ${NOTIFY_DOOR_PATH}`);
                 return;
@@ -113,6 +130,15 @@ export function startNotifyDoor(onBound, port = NOTIFY_DOOR_PORT) {
                 say(`the chat door on ${port} stopped serving (${cause}); rebinding`);
                 return;
             }
+            if (cause === "EADDRINUSE" && resident?.takeover === true) {
+                if (Date.now() >= giveUpAt) {
+                    say(`takeover gave up after ${TAKEOVER_BIND.giveUpMs / 1000}s: the chat door on ${port} was never let go by the release serving it, so build ${resident.version} serves nothing and that release keeps answering`);
+                    resident.onTakeoverGaveUp();
+                    return;
+                }
+                setTimeout(attempt, TAKEOVER_BIND.retryMs);
+                return;
+            }
             if (cause === lastCause)
                 return;
             lastCause = cause;

package/dist/gateway/sessionDriver.js

@@ -101,9 +101,13 @@ function sameBoard(a, b) {
 function heldByWords(claim) {
     return `#${claim.storyId} is held by ${claim.name} (${String(claim.sessionId).replace(/^hold:/, "")}) — heartbeat ${claim.at}${claim.why === undefined ? "" : ` — why: ${claim.why}`}`;
 }
-/** The hold a conversation writes for a story: a `hold` in the conversation's own name, addressed by this machine and this process exactly as the board's engine writes one (#2838). */
-function holdOf(name, storyId, board, now) {
-    return { storyId, name, sessionId: `hold:${hostname()}:${process.pid}`, at: boardStamp(now), kind: "hold", board };
+/** The address every hold of this daemon is written under and released by (#2838). */
+function holdAddress() {
+    return `hold:${hostname()}:${process.pid}`;
+}
+/** The hold a conversation writes for a story: a `hold` in the conversation's own name, addressed by this machine and this process exactly as the board's engine writes one (#2838). `drives` names the agent session this conversation runs, so a door can tell this hold from the work of the very session it holds for (#3850). */
+function holdOf(name, storyId, board, now, drives) {
+    return { storyId, name, sessionId: holdAddress(), at: boardStamp(now), kind: "hold", board, drives };
 }
 /** The claims the file still holds at `now`, lapsed ones dropped exactly as every reader of the file drops them; a file that is not there is a machine that has claimed nothing. */
 function readClaims(file, now) {
@@ -207,12 +211,14 @@ function writeClaims(file, claims) {
     }
 }
 /** BN's conversation takes the story's hold: the holder's name IS the conversation's id, so every refusal and every door name this conversation. Another session's standing hold, or its fresh `taken` claim, refuses in the file's own words (#2838/#2040). */
-function holdStory(file, name, storyId, board, now) {
-    const claim = holdOf(name, storyId, board, now);
+function holdStory(file, name, storyId, board, now, drives) {
+    const claim = holdOf(name, storyId, board, now, drives);
     underClaimsLock(file, () => {
         const before = readClaims(file, now);
         const on = (c) => c.storyId === claim.storyId && sameBoard(c.board, board);
         const prior = before.find(on);
+        if (prior !== undefined && prior.sessionId === drives)
+            return;
         // The derived sessionId is the same for every conversation of one daemon, so a DIFFERENT conversation in this process is another holder too — its own name is what tells two of them apart, and neither may overwrite the other.
         const mine = prior !== undefined && prior.sessionId === claim.sessionId && prior.name === claim.name;
         if (prior !== undefined && !mine && (prior.kind === "hold" || claim.kind === "hold"))
@@ -222,7 +228,7 @@ function holdStory(file, name, storyId, board, now) {
 }
 /** BN drops the hold it wrote when the work on the story ends: only the claim under its own address AND its own name goes — a different conversation of this daemon shares the address and must keep its own claim (#2838). */
 function releaseStory(file, name, storyId, board, now) {
-    const mine = holdOf(name, storyId, board, now).sessionId;
+    const mine = holdAddress();
     underClaimsLock(file, () => {
         const before = readClaims(file, now);
         const isMine = (c) => c.storyId === storyId && sameBoard(c.board, board) && c.sessionId === mine && c.name === name;
@@ -679,6 +685,7 @@ export class SessionDriver {
                 let beat;
                 if (hold !== undefined) {
                     const held = hold;
+                    this.refreshHold(c.id, held);
                     beat = setInterval(() => this.refreshHold(c.id, held), HOLD_BEAT_MS);
                     beat.unref();
                 }
@@ -705,13 +712,13 @@ export class SessionDriver {
         // NULL-OK: field storyId is OPTIONAL and therefore it is ok to check for NULL
         if (storyId === undefined)
             return undefined;
-        holdStory(claimsFile(), conversationId, storyId, project, Date.now());
+        holdStory(claimsFile(), conversationId, storyId, project, Date.now(), readConversation(conversationId).sessionId);
         return { storyId, board: project };
     }
     /** The hold is refreshed so it never lapses while the turn it belongs to runs. */
     refreshHold(conversationId, hold) {
         try {
-            holdStory(claimsFile(), conversationId, hold.storyId, hold.board, Date.now());
+            holdStory(claimsFile(), conversationId, hold.storyId, hold.board, Date.now(), readConversation(conversationId).sessionId);
         }
         catch (err) {
             if (!(err instanceof Error))

package/dist/googlehome/foyer-client.js

@@ -0,0 +1,210 @@
+// 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));
+}