@sirenodeck/sirenodeck 0.1.1-alpha.0

package/src/builtin-addons/weather/buttons/weather/pages.tsx

@@ -0,0 +1,109 @@
+import { type ReactElement } from "react"
+
+import { Chip, Text } from "@/ui"
+import { type WeatherSnapshot } from "../../provider/types"
+import { WeatherIcon } from "./icons"
+
+export interface WeatherPageProps {
+  snapshot: WeatherSnapshot
+  unitTemp: string
+  unitWind: string
+  city?: string
+}
+
+const MainPage = ({
+  snapshot,
+  unitTemp,
+  city,
+}: WeatherPageProps): ReactElement => (
+  <div className="flex h-full w-full flex-col items-center justify-center gap-1">
+    <WeatherIcon code={snapshot.wmoCode} className="h-10 w-10" />
+    <div className="-mt-1 flex flex-col gap-0.5">
+      <Text
+        size="xl"
+        tone="fg"
+        className="font-semibold leading-none"
+        text={`${snapshot.temperature?.toFixed(0) ?? ""}${unitTemp}`}
+      />
+      {city && <Text size="sm" tone="fg" fit="ellipsis" text={city} />}
+    </div>
+  </div>
+)
+
+const DataPage = ({
+  snapshot,
+  unitWind,
+  city,
+}: WeatherPageProps): ReactElement => (
+  <div className="flex h-full w-full flex-col items-center justify-center gap-1">
+    <Text size="sm" tone="primary" fit="ellipsis" text={city || "---"} />
+    {snapshot.windSpeed !== undefined && (
+      <Chip
+        tone="foreground"
+        size="sm"
+        text={`${snapshot.windSpeed.toFixed(0)} ${unitWind}`}
+      />
+    )}
+    {snapshot.description && (
+      <Text size="xs" tone="fg" fit="ellipsis" text={snapshot.description} />
+    )}
+  </div>
+)
+
+const HourlyForecastPage = ({
+  snapshot,
+  unitTemp,
+}: WeatherPageProps): ReactElement => {
+  const entries = snapshot.hourly?.slice(0, 2) ?? []
+  return (
+    <div className="flex items-center justify-center gap-2">
+      {entries.map((e) => (
+        <span key={e.time} className="flex flex-col items-center gap-0.5">
+          <Text size="xs" tone="fg" text={`${e.time}h`} />
+          <WeatherIcon code={e.wmoCode} className="h-8 w-8" />
+          <Text
+            size="xs"
+            tone="fg"
+            text={`${e.temperature.toFixed(0)}${unitTemp}`}
+          />
+        </span>
+      ))}
+    </div>
+  )
+}
+
+const DailyForecastPage = ({
+  snapshot,
+  unitTemp,
+}: WeatherPageProps): ReactElement => {
+  const entries = snapshot.daily?.slice(0, 2) ?? []
+  const weekDays = ["SUN", "MON", "TUE", "WED", "THU", "FRI", "SAT"]
+  return (
+    <div className="flex items-center justify-center gap-2">
+      {entries.map((e) => {
+        const d = new Date(e.date)
+        const dayName = weekDays[d.getDay()] ?? e.date.slice(5)
+        return (
+          <span key={e.date} className="flex flex-col items-center gap-0.5">
+            <Text size="xs" tone="fg" text={dayName} />
+            <WeatherIcon code={e.wmoCode} className="h-8 w-8" />
+            <Text
+              size="xs"
+              tone="primary"
+              text={`${e.tempMin.toFixed(0)}${unitTemp}`}
+            />
+            <Text
+              size="xs"
+              tone="fg"
+              text={`${e.tempMax.toFixed(0)}${unitTemp}`}
+            />
+          </span>
+        )
+      })}
+    </div>
+  )
+}
+
+export const weatherPageRenderers: ReadonlyArray<
+  (props: WeatherPageProps) => ReactElement
+> = Object.freeze([MainPage, DataPage, HourlyForecastPage, DailyForecastPage])

package/src/builtin-addons/weather/domain/codes.ts

@@ -0,0 +1,35 @@
+export const WMO_CODE_TO_DESCRIPTION: Record<number, string> = {
+  0: "Clear",
+  1: "Mostly clear",
+  2: "Partly cloudy",
+  3: "Cloudy",
+  45: "Foggy",
+  48: "Rime fog",
+  51: "Light drizzle",
+  53: "Drizzle",
+  55: "Heavy drizzle",
+  56: "Freezing drizzle",
+  57: "Heavy freezing drizzle",
+  61: "Light rain",
+  63: "Rain",
+  65: "Heavy rain",
+  66: "Freezing rain",
+  67: "Heavy freezing rain",
+  71: "Light snow",
+  73: "Snow",
+  75: "Heavy snow",
+  77: "Snow grains",
+  80: "Light showers",
+  81: "Showers",
+  82: "Heavy showers",
+  85: "Snow showers",
+  86: "Heavy snow showers",
+  95: "Thunderstorm",
+  96: "Thunderstorm + hail",
+  99: "Severe thunderstorm",
+}
+
+export const describeWeatherCode = (code: number | undefined): string => {
+  if (code === undefined) return "Unknown"
+  return WMO_CODE_TO_DESCRIPTION[code] ?? "Unknown"
+}

package/src/builtin-addons/weather/domain/fetch.ts

@@ -0,0 +1,47 @@
+import type {
+  WeatherButtonConfig,
+  WeatherLocation,
+} from "../buttons/weather/config"
+import type { WeatherSnapshot } from "../provider/types"
+
+import { describeWeatherCode } from "./codes"
+
+const OPEN_METEO_URL = "https://api.open-meteo.com/v1/forecast"
+
+export const fetchWeather = async (
+  location: WeatherLocation,
+  units: WeatherButtonConfig["units"],
+  signal?: AbortSignal,
+): Promise<WeatherSnapshot> => {
+  const tempUnit = units === "imperial" ? "fahrenheit" : "celsius"
+  const windUnit = units === "imperial" ? "mph" : "kmh"
+  const url = new URL(OPEN_METEO_URL)
+  url.searchParams.set("latitude", String(location.latitude))
+  url.searchParams.set("longitude", String(location.longitude))
+  url.searchParams.set("current", "temperature_2m,wind_speed_10m,weather_code")
+  url.searchParams.set("temperature_unit", tempUnit)
+  url.searchParams.set("wind_speed_unit", windUnit)
+  const response = await fetch(url.toString(), { signal })
+  if (!response.ok) {
+    throw new Error(`Open-Meteo HTTP ${response.status}`)
+  }
+  const json = (await response.json()) as {
+    current?: {
+      temperature_2m?: number
+      wind_speed_10m?: number
+      weather_code?: number
+    }
+  }
+  const current = json.current ?? {}
+  return {
+    available: true,
+    temperature: current.temperature_2m,
+    windSpeed: current.wind_speed_10m,
+    description:
+      current.weather_code !== undefined
+        ? describeWeatherCode(current.weather_code)
+        : undefined,
+    wmoCode: current.weather_code,
+    units,
+  }
+}

package/src/builtin-addons/weather/index.d.ts

@@ -0,0 +1,5 @@
+import type { AddonManifestV1 } from "@/addon/api"
+
+declare const manifest: AddonManifestV1
+export default manifest
+export { manifest }

package/src/builtin-addons/weather/index.ts

@@ -0,0 +1,23 @@
+import type { AddonManifestV1 } from "@/addon/api"
+
+import { globalService } from "./backend"
+import weatherBackend from "./buttons/weather/backend"
+import weatherFrontend from "./buttons/weather/frontend"
+
+export { globalService }
+
+export const manifest: AddonManifestV1 = {
+  apiVersion: 1,
+  name: "weather",
+  buttonTypes: {
+    "weather:weather": {
+      frontend: weatherFrontend,
+      service: { ...weatherBackend, gestureHandlers: ["tap"] as const },
+    },
+  },
+  publishIntervalMs: 600_000,
+  globalService,
+}
+
+export const weatherAddon = manifest
+export default manifest

package/src/builtin-addons/weather/poller.ts

@@ -0,0 +1,70 @@
+import { existsSync, readFileSync } from "node:fs"
+import { join } from "node:path"
+
+import { fetchWeather } from "./domain/fetch"
+import type { AddonPoller } from "@/addon/api-types"
+
+const readWeatherConfig = (): {
+  location?: { latitude: number; longitude: number; name?: string }
+  units: "metric" | "imperial"
+} => {
+  try {
+    const configPath = join(process.cwd(), "config.yml")
+    if (!existsSync(configPath)) return { units: "metric" }
+    const raw = readFileSync(configPath, "utf8")
+    const block = raw.match(/core:weather:\s*\n((?:\s+[^\n]+\n)*)/)
+    if (block === null) return { units: "metric" }
+    const inner = block[1] ?? ""
+    const latMatch = inner.match(/latitude:\s*([\d.-]+)/)
+    const lonMatch = inner.match(/longitude:\s*([\d.-]+)/)
+    const unitsMatch = inner.match(/units:\s*(metric|imperial)/)
+    const nameMatch = inner.match(/name:\s*([^\n]+)/)
+    if (latMatch === null || lonMatch === null) return { units: "metric" }
+    return {
+      location: {
+        latitude: Number.parseFloat(latMatch[1] as string),
+        longitude: Number.parseFloat(lonMatch[1] as string),
+        ...(nameMatch !== null ? { name: nameMatch[1]?.trim() } : {}),
+      },
+      units: (unitsMatch?.[1] as "metric" | "imperial" | undefined) ?? "metric",
+    }
+  } catch {
+    return { units: "metric" }
+  }
+}
+
+export const createPoller = (): AddonPoller => ({
+  channels: [
+    {
+      channel: "weather:current",
+      intervalMs: 600_000,
+      poll: async () => {
+        const cfg = readWeatherConfig()
+        if (cfg.location === undefined) {
+          return {
+            available: false,
+            units: cfg.units,
+            description: "Configure weather",
+          }
+        }
+        try {
+          const snapshot = await fetchWeather(cfg.location, cfg.units)
+          return {
+            available: snapshot.available,
+            temperature: snapshot.temperature,
+            windSpeed: snapshot.windSpeed,
+            description: snapshot.description,
+            wmoCode: snapshot.wmoCode,
+            units: cfg.units,
+          }
+        } catch (err) {
+          return {
+            available: false,
+            units: cfg.units,
+            description: err instanceof Error ? err.message : "fetch failed",
+          }
+        }
+      },
+    },
+  ],
+})

package/src/builtin-addons/weather/provider/city-key.ts

@@ -0,0 +1,9 @@
+import type { GeocodedLocation } from "./geocode"
+
+const roundCoord = (n: number, decimals = 2): number => {
+  const factor = 10 ** decimals
+  return Math.round(n * factor) / factor
+}
+
+export const cityKey = (loc: GeocodedLocation): string =>
+  `${roundCoord(loc.latitude)},${roundCoord(loc.longitude)}`

package/src/builtin-addons/weather/provider/codes.ts

@@ -0,0 +1,35 @@
+export const WMO_CODE_TO_DESCRIPTION: Record<number, string> = {
+  0: "Clear",
+  1: "Mostly clear",
+  2: "Partly cloudy",
+  3: "Cloudy",
+  45: "Foggy",
+  48: "Rime fog",
+  51: "Light drizzle",
+  53: "Drizzle",
+  55: "Heavy drizzle",
+  56: "Freezing drizzle",
+  57: "Heavy freezing drizzle",
+  61: "Light rain",
+  63: "Rain",
+  65: "Heavy rain",
+  66: "Freezing rain",
+  67: "Heavy freezing rain",
+  71: "Light snow",
+  73: "Snow",
+  75: "Heavy snow",
+  77: "Snow grains",
+  80: "Light showers",
+  81: "Showers",
+  82: "Heavy showers",
+  85: "Snow showers",
+  86: "Heavy snow showers",
+  95: "Thunderstorm",
+  96: "Thunderstorm + hail",
+  99: "Severe thunderstorm",
+}
+
+export const describeWeatherCode = (code: number | undefined): string => {
+  if (code === undefined) return "Unknown"
+  return WMO_CODE_TO_DESCRIPTION[code] ?? "Unknown"
+}

package/src/builtin-addons/weather/provider/fetch.ts

@@ -0,0 +1,97 @@
+import type { WeatherButtonConfig } from "../buttons/weather/config"
+import { WeatherSnapshot } from "./types"
+
+import { describeWeatherCode } from "./codes"
+import type { GeocodedLocation } from "./geocode"
+import { DailyForecastEntry, HourlyForecastEntry } from "./types"
+
+const OPEN_METEO_URL = "https://api.open-meteo.com/v1/forecast"
+
+export const fetchWeather = async (
+  location: GeocodedLocation,
+  units: WeatherButtonConfig["units"],
+  signal?: AbortSignal,
+): Promise<WeatherSnapshot> => {
+  const tempUnit = units === "imperial" ? "fahrenheit" : "celsius"
+  const windUnit = units === "imperial" ? "mph" : "kmh"
+  const url = new URL(OPEN_METEO_URL)
+  url.searchParams.set("latitude", String(location.latitude))
+  url.searchParams.set("longitude", String(location.longitude))
+  url.searchParams.set("current", "temperature_2m,wind_speed_10m,weather_code")
+  url.searchParams.set(
+    "hourly",
+    "temperature_2m,weather_code,precipitation_probability",
+  )
+  url.searchParams.set(
+    "daily",
+    "weather_code,temperature_2m_max,temperature_2m_min,precipitation_sum",
+  )
+  url.searchParams.set("temperature_unit", tempUnit)
+  url.searchParams.set("wind_speed_unit", windUnit)
+  url.searchParams.set("timezone", "auto")
+  url.searchParams.set("forecast_days", "7")
+  const response = await fetch(url.toString(), { signal })
+  if (!response.ok) {
+    throw new Error(`Open-Meteo HTTP ${response.status}`)
+  }
+  const json = (await response.json()) as {
+    current?: {
+      temperature_2m?: number
+      wind_speed_10m?: number
+      weather_code?: number
+    }
+    hourly?: {
+      time?: string[]
+      temperature_2m?: number[]
+      weather_code?: number[]
+      precipitation_probability?: number[]
+    }
+    daily?: {
+      time?: string[]
+      weather_code?: number[]
+      temperature_2m_max?: number[]
+      temperature_2m_min?: number[]
+      precipitation_sum?: number[]
+    }
+  }
+  const current = json.current ?? {}
+  const hourly: HourlyForecastEntry[] = []
+  if (json.hourly?.time && json.hourly.temperature_2m) {
+    for (let i = 0; i < Math.min(24, json.hourly.time.length); i++) {
+      const hour = new Date(json.hourly.time[i]!).getHours()
+      if (!isNaN(hour)) {
+        hourly.push({
+          time: hour.toString().padStart(2, "0"),
+          temperature: json.hourly.temperature_2m[i] ?? 0,
+          wmoCode: json.hourly.weather_code?.[i] ?? 0,
+          precipitationChance: json.hourly.precipitation_probability?.[i] ?? 0,
+        })
+      }
+    }
+  }
+  const daily: DailyForecastEntry[] = []
+  if (json.daily?.time) {
+    for (let i = 0; i < json.daily.time.length; i++) {
+      daily.push({
+        date: json.daily.time[i] ?? "",
+        wmoCode: json.daily.weather_code?.[i] ?? 0,
+        tempMax: json.daily.temperature_2m_max?.[i] ?? 0,
+        tempMin: json.daily.temperature_2m_min?.[i] ?? 0,
+        precipitationSum: json.daily.precipitation_sum?.[i] ?? 0,
+      })
+    }
+  }
+  return {
+    available: true,
+    temperature: current.temperature_2m,
+    windSpeed: current.wind_speed_10m,
+    description:
+      current.weather_code !== undefined
+        ? describeWeatherCode(current.weather_code)
+        : undefined,
+    wmoCode: current.weather_code,
+    units,
+    hourly,
+    daily,
+  }
+}

package/src/builtin-addons/weather/provider/geocode.ts

@@ -0,0 +1,67 @@
+import type { WeatherLocation } from "../buttons/weather/config"
+
+const GEOCODING_URL = "https://geocoding-api.open-meteo.com/v1/search"
+
+export interface GeocodedLocation {
+  latitude: number
+  longitude: number
+  name?: string
+}
+
+const cache = new Map<string, GeocodedLocation>()
+
+export const geocodeLocation = async (
+  location: string,
+  signal?: AbortSignal,
+): Promise<GeocodedLocation> => {
+  const cached = cache.get(location)
+  if (cached) return cached
+
+  const url = new URL(GEOCODING_URL)
+  url.searchParams.set("name", location)
+  url.searchParams.set("count", "1")
+  url.searchParams.set("language", "en")
+  url.searchParams.set("format", "json")
+
+  const response = await fetch(url.toString(), { signal })
+  if (!response.ok) {
+    throw new Error(`Geocoding failed: HTTP ${response.status}`)
+  }
+
+  const json = (await response.json()) as {
+    results?: Array<{
+      latitude: number
+      longitude: number
+      name: string
+      country?: string
+    }>
+  }
+
+  const result = json.results?.[0]
+  if (!result) {
+    throw new Error(`Location not found: ${location}`)
+  }
+
+  const resolved: GeocodedLocation = {
+    latitude: result.latitude,
+    longitude: result.longitude,
+    name: result.country ? `${result.name}, ${result.country}` : result.name,
+  }
+
+  cache.set(location, resolved)
+  return resolved
+}
+
+export const resolveLocation = async (
+  location: WeatherLocation,
+  signal?: AbortSignal,
+): Promise<GeocodedLocation> => {
+  if (typeof location === "string") {
+    return geocodeLocation(location, signal)
+  }
+  return {
+    latitude: location.latitude,
+    longitude: location.longitude,
+    name: location.name ?? "Unknown",
+  }
+}

package/src/builtin-addons/weather/provider/types.ts

@@ -0,0 +1,42 @@
+import type { WeatherLocation } from "../buttons/weather/config"
+
+const units = ["metric", "imperial"] as const
+type Units = (typeof units)[number]
+
+export interface CityEntry {
+  readonly location: WeatherLocation
+  readonly units: Units
+}
+
+export type HourlyForecastEntry = {
+  readonly time: string
+  readonly temperature: number
+  readonly description?: string
+  readonly wmoCode?: number
+  readonly precipitationChance?: number
+}
+
+export type DailyForecastEntry = {
+  readonly date: string
+  readonly tempMin: number
+  readonly tempMax: number
+  readonly description?: string
+  readonly wmoCode?: number
+  readonly precipitationSum?: number
+}
+
+export type WeatherSnapshot = {
+  readonly available: boolean
+  readonly temperature?: number
+  readonly windSpeed?: number
+  readonly description?: string
+  readonly units: Units
+  readonly wmoCode?: number
+  readonly hourly?: ReadonlyArray<HourlyForecastEntry>
+  readonly daily?: ReadonlyArray<DailyForecastEntry>
+}
+
+/** Aggregate poll result broadcast on `weather:current`, keyed by city. */
+export type WeatherStateSnapshot = {
+  readonly byCity: Readonly<Record<string, WeatherSnapshot>>
+}

package/src/builtin-addons/weather/sirenodeck.json

@@ -0,0 +1,6 @@
+{
+  "kind": "addon",
+  "apiVersion": 1,
+  "name": "weather",
+  "entry": "index.ts"
+}