@glasshome/sync-layer 0.5.0 → 0.7.0

package/dist/calendar/track.d.ts

@@ -0,0 +1,19 @@
+import type { EntityId } from "../core/types";
+import type { CalendarWindowOptions } from "./types";
+/**
+ * Start tracking live events for a calendar entity. Returns the untrack
+ * function. Safe while disconnected: the subscription activates on the next
+ * `forceResubscribeCalendars()` (called by the connection layer on connect
+ * and reconnect).
+ */
+export declare function trackCalendarEvents(entityId: EntityId, options?: CalendarWindowOptions): () => void;
+/**
+ * Reconcile every tracked calendar, dropping current subscription handles
+ * first. The connection layer calls this on connect and after reconnect:
+ * an unchanged window is no proof the old subscription is alive, so each
+ * tracked entity resubscribes (HA re-pushes the snapshot, refreshing the
+ * store through any missed changes).
+ */
+export declare function forceResubscribeCalendars(): Promise<void>;
+/** Test-only: drop all tracking state and timers. */
+export declare function resetCalendarTracking(): void;

package/dist/calendar/types.d.ts

@@ -0,0 +1,32 @@
+import type { EntityId } from "../core/types";
+/**
+ * One calendar event as HA serializes it over `calendar/event/subscribe`:
+ * dates/datetimes are ISO strings (date-only for all-day events), and
+ * None-valued fields are omitted.
+ */
+export interface CalendarEvent {
+    start: string;
+    end: string;
+    summary: string;
+    description?: string;
+    location?: string;
+    uid?: string;
+    recurrence_id?: string;
+    rrule?: string;
+}
+/** Live event window for one calendar entity, held in the store. */
+export interface CalendarEventsData {
+    entityId: EntityId;
+    events: CalendarEvent[];
+    /** True until the first snapshot for the current subscription arrives. */
+    loading: boolean;
+    error: Error | null;
+    /** Subscribed window bounds (ISO). */
+    start: string;
+    end: string;
+}
+/** Per-tracker window request, in whole days relative to now. */
+export interface CalendarWindowOptions {
+    daysBehind?: number;
+    daysAhead?: number;
+}

package/dist/core/privileged-conn.d.ts

@@ -0,0 +1,29 @@
+/**
+ * The privileged Home Assistant connection, held outside the shared store.
+ *
+ * This handle tunnels arbitrary HA traffic: the worker's `case "send"` forwards
+ * whatever arrives on it after a shape check only, because capability
+ * validation belongs on the per-widget MessagePorts, not here.
+ *
+ * It therefore must not be reachable from widget code. It used to live at
+ * `state.conn`, and `state` is exported from this package's entry, which the
+ * host serves to every widget bundle through its import map — so any widget
+ * could read the handle and call any service on any entity, regardless of the
+ * capabilities it declared and the user approved. Proven by execution, not
+ * argued: a widget-side `useService()` emitted `call_service`/`lock.unlock`
+ * onto the host's own channel (finding 46).
+ *
+ * Module-local and deliberately absent from `src/index.ts`. Not being exported
+ * is the entire mechanism, so exporting it — directly, or by parking the value
+ * on anything that is exported — reopens the hole. `check-widget-reachable-
+ * surface.ts` fails the build if it ever becomes reachable again.
+ *
+ * Plain variable rather than store state: every reader takes it imperatively
+ * inside an async fetcher or command, so none of them tracked it reactively.
+ * `state.connectionState` remains the reactive signal for connection status.
+ */
+import type { HaLink } from "./store";
+/** Read the live connection. Null before connect and after disconnect. */
+export declare function privilegedConn(): HaLink | null;
+/** Set by the connection layer on connect/disconnect. Host-side callers only. */
+export declare function setPrivilegedConn(conn: HaLink | null): void;

package/dist/core/store.d.ts

@@ -1,5 +1,6 @@
 /** Central reactive state store for sync-layer using SolidJS createStore. */
 import type { SetStoreFunction, Store } from "solid-js/store";
+import type { CalendarEventsData } from "../calendar/types";
 import type { CameraStreamData } from "../camera/types";
 import type { EntityHistoryData } from "../history/types";
 import type { WeatherForecastsData } from "../weather/types";
@@ -24,8 +25,6 @@ export interface HaLink {
     subscribeEvents(callback: (event: unknown) => void, eventType?: string): Promise<() => void | Promise<void>>;
 }
 export interface GlassHomeState {
-    /** Live HA link (real socket, worker bridge facade, or mock) */
-    conn: HaLink | null;
     /** Current connection state */
     connectionState: ConnectionState;
     /** Connection error (if any) */
@@ -57,6 +56,8 @@ export interface GlassHomeState {
     history: Record<EntityId, EntityHistoryData>;
     /** Weather forecasts data (keyed by entity ID) */
     forecasts: Record<EntityId, WeatherForecastsData>;
+    /** Live calendar events (keyed by entity ID), maintained by calendar/track */
+    calendars: Record<EntityId, CalendarEventsData>;
     /** Camera stream data (keyed by entity ID) */
     streams: Record<EntityId, CameraStreamData>;
 }

package/dist/host-api.d.ts

@@ -0,0 +1,50 @@
+/**
+ * One-shot handoff of the host-only surface.
+ *
+ * The problem this solves: the host import map serves this package's entry to
+ * every widget bundle, so everything exported there is callable by untrusted
+ * widget code. But the host needs privileged operations from the same package —
+ * connect the bridge, authenticate, disconnect — and it cannot import them
+ * through a private subpath, because the store must be ONE instance shared with
+ * widgets. An unserved subpath gets bundled into the host and forks the store
+ * (finding 45); a served one is reachable by widgets again (finding 46). A
+ * subpath cannot be both, so hiding is not available.
+ *
+ * So the surface stays on the shared entry and is protected by ORDER instead of
+ * by visibility: `claimHostApi()` yields the API to its first caller and null to
+ * everyone after. The host claims it while booting; widget bundles are fetched
+ * and evaluated later, by which point there is nothing left to take.
+ *
+ * Why these members are dangerous in a widget's hands:
+ * - attachBridgeToStore / createHaBridge: install a connection, i.e. replace the
+ *   host's link with one the widget controls — every subsequent service call is
+ *   intercepted and every entity the dashboard renders can be fabricated.
+ * - authenticateWithOAuth: returns an `Auth` carrying a live access token.
+ * - disconnect / detachBridgeFromStore: drop the household's connection.
+ * - loadDemoData / unloadDemoData: overwrite live state with fixtures.
+ */
+import { authenticateWithOAuth } from "./connection/auth";
+import { applyBridgeConnState, attachBridgeToStore, detachBridgeFromStore, reloadAfterBridgeReconnect } from "./connection/bridged";
+import { disconnect } from "./connection/manager";
+import { loadDemoData, unloadDemoData } from "./demo/demo-provider";
+import { createHaBridge } from "./worker/bridge-client";
+export interface HostApi {
+    attachBridgeToStore: typeof attachBridgeToStore;
+    detachBridgeFromStore: typeof detachBridgeFromStore;
+    applyBridgeConnState: typeof applyBridgeConnState;
+    reloadAfterBridgeReconnect: typeof reloadAfterBridgeReconnect;
+    createHaBridge: typeof createHaBridge;
+    authenticateWithOAuth: typeof authenticateWithOAuth;
+    disconnect: typeof disconnect;
+    loadDemoData: typeof loadDemoData;
+    unloadDemoData: typeof unloadDemoData;
+}
+/**
+ * Take the host-only surface. Returns it once; null on every later call.
+ *
+ * Call it exactly once, during host boot, and keep the result in a module the
+ * import map does not serve. Calling it from anywhere else is what this guards
+ * against, so a null return means something already claimed it — treat that as
+ * a fatal misconfiguration, not a retry.
+ */
+export declare function claimHostApi(): HostApi | null;

package/dist/index.d.ts

@@ -4,15 +4,23 @@
  * Type-safe, reactive state synchronization layer for Home Assistant
  * Uses SolidJS createStore for reactive state management.
  *
+ * THIS ENTRY IS AN ACCESS-CONTROL SURFACE, not an ordinary barrel. The host
+ * import map serves it to every untrusted widget bundle, so anything exported
+ * here is callable by widget code. Before adding an export, ask who outside
+ * this package needs it: in-package callers use relative imports and need
+ * nothing here, host-only lifecycle belongs on claimHostApi(), and widget
+ * hooks belong on the ./solid subpath. Types are always safe; they carry no
+ * authority. scripts/check-widget-reachable-surface.ts guards this, but it is
+ * a DENYLIST of known-dangerous names and is blind to any handle invented
+ * after it was written — it cannot be relied on to catch a new mistake.
+ *
  * @packageDocumentation
  */
-export { addDebugIncomingMessageListener, addDebugOutgoingMessageListener, } from "./connection/adapter";
 export type { ConnectionOptions } from "./connection/manager";
-export { disconnect, getConnection, getConnectionState, initConnection, isConnected, } from "./connection/manager";
+export { getConnectionState, isConnected } from "./connection/manager";
 export { registerEntity } from "./connection/subscription-manager";
 export type { SyncLayerConnection } from "./connection/types";
 export type { OAuthOptions } from "./connection/auth";
-export { authenticateWithOAuth, authenticateWithToken, isAuthValid, refreshAuth, } from "./connection/auth";
 export { area, areas } from "./query/area-builder";
 export { entities, entity } from "./query/builder";
 export { entitiesByAreaAndDomain, entitiesWhere, searchEntities, } from "./query/helpers";
@@ -22,7 +30,7 @@ export type { CommandOptions, CommandResult, EntityUpdateFields, ServiceCallCont
 export type { GlassHomeState } from "./core/store";
 export type { AreaId, AreaView, ConnectionState, DeviceId, DeviceView, EntityDomain, EntityId, EntityView, HassEntity, } from "./core/types";
 export { extractDomain } from "./core/types";
-export { resetStore, setState, state } from "./core/store";
+export { state } from "./core/store";
 export type { CallServiceRequest, CoreEventType, Domain, EntityCategory, EntityRegistryEntry, EventStateChangedData, HAEvent, HassConfig, HassUnitSystem, RegistryEntryDisabler, RegistryEntryHider, ServiceCall, ServiceName, WsCommandType, WsResult, } from "@glasshome/ha-types";
 export { fetchStream, fetchStreamData } from "./camera/fetch";
 export { getStream, refreshStream } from "./camera/query";
@@ -41,11 +49,12 @@ export { fetchStatisticsDuringPeriod, normalizeStatisticTime, } from "./history/
 export type { StatisticsPeriod, StatisticsQueryOptions, StatisticValue, } from "./history/statistics";
 export type { EntityHistoryData, EntityHistoryQueryOptions, EntityHistoryResult, EntityHistoryState, HistoryData, HistoryQueryOptions, HistoryResult, HistoryStates, TimelineState, } from "./history/types";
 export { fetchForecast, fetchForecastData, fetchForecasts } from "./weather/fetch";
+export type { CalendarEvent, CalendarEventsData, CalendarWindowOptions } from "./calendar/types";
 export { getForecast, getForecasts, refreshForecast, refreshForecasts } from "./weather/query";
 export type { EntityForecastQueryOptions, ForecastQueryOptions, ForecastResult, ForecastsResult, ForecastType, WeatherForecast, WeatherForecastData, WeatherForecasts, WeatherForecastsData, } from "./weather/types";
-export { applyDemoServiceCall, createDemoFixtures, isDemoMode, loadDemoData, startDemoEnergyTicker, stopDemoEnergyTicker, unloadDemoData, } from "./demo/demo-provider";
+export { applyDemoServiceCall, createDemoFixtures, isDemoMode, startDemoEnergyTicker, stopDemoEnergyTicker, } from "./demo/demo-provider";
 export declare const VERSION = "0.2.1";
-export { applyBridgeConnState, attachBridgeToStore, detachBridgeFromStore, reloadAfterBridgeReconnect, } from "./connection/bridged";
-export { BridgeNeedsAuthError, createHaBridge, type BridgeConnectOptions, type BridgeEvents, type HaBridge, } from "./worker/bridge-client";
+export { BridgeNeedsAuthError, type BridgeConnectOptions, type BridgeEvents, type HaBridge, } from "./worker/bridge-client";
+export { claimHostApi, type HostApi } from "./host-api";
 export type { AuthMode, ConnState, OAuthTokenData } from "./worker/protocol";
 export { runHaBridgeWorker, type WorkerScope } from "./worker/worker-main";