@sirenodeck/sirenodeck 0.1.1-alpha.0

package/src/system/providers/active-app/linux.ts

@@ -0,0 +1,245 @@
+import type pino from "pino"
+
+import type { ActiveAppProvider, ActiveAppSnapshot } from "../active-app"
+import {
+  type CommandExecutor,
+  type LinuxDbusBus,
+  type LinuxDbusProxyObject,
+} from "../shared"
+import {
+  createWaylandGnomeProvider,
+  hasWaylandGnomeSession,
+  shouldUseWaylandGnomeProvider,
+} from "./wayland-gnome"
+
+export interface LinuxActiveAppDeps {
+  readonly dbus?: LinuxDbusBus
+  readonly executor: CommandExecutor
+  readonly logger: pino.Logger
+  readonly pollIntervalMs?: number
+  readonly env?: NodeJS.ProcessEnv
+}
+
+const DEFAULT_POLL_MS = 1_000
+
+const parseDbusEvalResult = (
+  raw: unknown,
+): { wmClass: string; title: string; pid: number | null } | null => {
+  if (typeof raw !== "string" || raw.length === 0) return null
+  try {
+    const parsed = JSON.parse(raw) as {
+      wm_class?: string
+      title?: string
+      pid?: number
+    }
+    const wmClass = typeof parsed.wm_class === "string" ? parsed.wm_class : ""
+    const title = typeof parsed.title === "string" ? parsed.title : ""
+    const pid =
+      typeof parsed.pid === "number" && Number.isFinite(parsed.pid)
+        ? parsed.pid
+        : null
+    if (wmClass.length === 0 && title.length === 0) return null
+    return { wmClass, title, pid }
+  } catch {
+    return null
+  }
+}
+
+const readProcName = async (
+  executor: CommandExecutor,
+): Promise<string | null> => {
+  const result = await executor.run("sh", [
+    "-c",
+    "cat /proc/$$/comm 2>/dev/null || true",
+  ])
+  const name = result.stdout.trim()
+  return name.length > 0 ? name : null
+}
+
+const readForegroundProc = async (
+  executor: CommandExecutor,
+): Promise<{ name: string; pid: number | null } | null> => {
+  const winIdResult = await executor.run("sh", [
+    "-c",
+    "xdotool getactivewindow 2>/dev/null || xprop -root _NET_ACTIVE_WINDOW 2>/dev/null | awk '{print $5}' || true",
+  ])
+  const winId = winIdResult.stdout.trim()
+  if (winId.length === 0) {
+    const name = await readProcName(executor)
+    return name === null ? null : { name, pid: null }
+  }
+  const pidResult = await executor.run("sh", [
+    "-c",
+    `xdotool getwindowpid ${winId} 2>/dev/null || true`,
+  ])
+  const pid = Number.parseInt(pidResult.stdout.trim(), 10)
+  if (!Number.isFinite(pid)) {
+    const name = await readProcName(executor)
+    return name === null ? null : { name, pid: null }
+  }
+  const nameResult = await executor.run("sh", [
+    "-c",
+    `cat /proc/${pid}/comm 2>/dev/null || true`,
+  ])
+  const name = nameResult.stdout.trim()
+  if (name.length === 0) {
+    return { name: `pid:${pid}`, pid }
+  }
+  return { name, pid }
+}
+
+const D_BUS_GNOME_SHELL = "org.gnome.Shell"
+const D_BUS_GNOME_SHELL_PATH = "/org/gnome/Shell"
+
+const dbusSnapshot = async (
+  bus: LinuxDbusBus,
+): Promise<ActiveAppSnapshot | null> => {
+  const proxy: LinuxDbusProxyObject = await bus.getProxyObject(
+    D_BUS_GNOME_SHELL,
+    D_BUS_GNOME_SHELL_PATH,
+  )
+  const iface = proxy.getInterface("org.gnome.Shell")
+  if (iface.Eval === undefined) return null
+  const result = await iface.Eval(
+    "global.display.focus_window && JSON.stringify({wm_class: global.display.focus_window.wm_class, title: global.display.focus_window.title, pid: global.display.focus_window.pid})",
+  )
+  return parseDbusEvalResult(result) === null
+    ? null
+    : (() => {
+        const parsed = parseDbusEvalResult(result) as {
+          wmClass: string
+          title: string
+          pid: number | null
+        }
+        return {
+          name: parsed.wmClass.length > 0 ? parsed.wmClass : parsed.title,
+          windowTitle: parsed.title.length > 0 ? parsed.title : null,
+          processId: parsed.pid,
+        }
+      })()
+}
+
+const fallbackSnapshot = async (
+  executor: CommandExecutor,
+): Promise<ActiveAppSnapshot | null> => {
+  const fg = await readForegroundProc(executor)
+  if (fg === null) return null
+  return {
+    name: fg.name,
+    windowTitle: null,
+    processId: fg.pid,
+  }
+}
+
+const sameSnapshot = (
+  a: ActiveAppSnapshot | null,
+  b: ActiveAppSnapshot | null,
+): boolean => {
+  if (a === null && b === null) return true
+  if (a === null || b === null) return false
+  return (
+    a.name === b.name &&
+    a.windowTitle === b.windowTitle &&
+    a.processId === b.processId
+  )
+}
+
+export const createLinuxActiveAppProvider = async (
+  deps: LinuxActiveAppDeps,
+): Promise<ActiveAppProvider> => {
+  if (
+    shouldUseWaylandGnomeProvider(deps.env) ||
+    (await hasWaylandGnomeSession({ env: deps.env, executor: deps.executor }))
+  ) {
+    deps.logger.info(
+      "active-app: detected GNOME Wayland session, using 'Window Calls Extended' provider",
+    )
+    try {
+      return await createWaylandGnomeProvider({
+        ...(deps.dbus !== undefined ? { dbus: deps.dbus } : {}),
+        logger: deps.logger,
+        ...(deps.pollIntervalMs !== undefined
+          ? { pollIntervalMs: deps.pollIntervalMs }
+          : {}),
+      })
+    } catch (err) {
+      // ponytail: extension probe or interface lookup can throw if GNOME Shell
+      // is reachable but the extension isn't installed; fall through to the
+      // null provider below instead of crashing the daemon.
+      deps.logger.warn(
+        { err },
+        "active-app: GNOME Wayland provider init failed, using null provider",
+      )
+    }
+  }
+
+  const pollMs = deps.pollIntervalMs ?? DEFAULT_POLL_MS
+  const subscribers = new Set<(s: ActiveAppSnapshot | null) => void>()
+  let last: ActiveAppSnapshot | null = null
+  let stopped = false
+  const bus: LinuxDbusBus | null = deps.dbus ?? null
+  let dbusFailed = false
+
+  const snapshot = async (): Promise<ActiveAppSnapshot | null> => {
+    if (bus && !dbusFailed) {
+      try {
+        const snap = await dbusSnapshot(bus)
+        if (snap !== null) return snap
+        dbusFailed = true
+      } catch (err) {
+        deps.logger.debug(
+          { err },
+          "active-app: D-Bus snapshot failed, falling back to /proc",
+        )
+        dbusFailed = true
+      }
+    }
+    try {
+      return await fallbackSnapshot(deps.executor)
+    } catch (err) {
+      deps.logger.warn({ err }, "active-app: /proc fallback failed")
+      return last
+    }
+  }
+
+  let interval: ReturnType<typeof setInterval> | null = null
+  const start = (): void => {
+    if (interval !== null) return
+    interval = setInterval(() => {
+      if (stopped) return
+      void snapshot().then((s) => {
+        if (stopped) return
+        if (!sameSnapshot(last, s)) {
+          last = s
+          for (const handler of subscribers) handler(s)
+        }
+      })
+    }, pollMs)
+  }
+
+  start()
+
+  return {
+    async getActive() {
+      return snapshot()
+    },
+    subscribe(handler) {
+      subscribers.add(handler)
+      return () => {
+        subscribers.delete(handler)
+      }
+    },
+    async stop() {
+      stopped = true
+      if (interval !== null) {
+        clearInterval(interval)
+        interval = null
+      }
+      try {
+        bus?.disconnect?.()
+      } catch {
+        // ignore disconnect failures
+      }
+    },
+  }
+}

package/src/system/providers/active-app/wayland-gnome.ts

@@ -0,0 +1,303 @@
+import { sessionBus } from "dbus-next"
+
+import type pino from "pino"
+
+import type { ActiveAppProvider, ActiveAppSnapshot } from "../active-app"
+import {
+  logNull,
+  type CommandExecutor,
+  type LinuxDbusBus,
+  type LinuxDbusProxyObject,
+} from "../shared"
+
+export interface WaylandGnomeDeps {
+  readonly dbus?: LinuxDbusBus
+  readonly logger: pino.Logger
+  readonly pollIntervalMs?: number
+}
+
+const DEFAULT_POLL_MS = 500
+const MAX_CONSECUTIVE_POLL_FAILURES = 5
+const PROBE_TIMEOUT_MS = 3_000
+
+const GNOME_SHELL_SERVICE = "org.gnome.Shell"
+const GNOME_EXTENSION_PATH = "/org/gnome/Shell/Extensions/WindowsExt"
+const GNOME_EXTENSION_IFACE = "org.gnome.Shell.Extensions.WindowsExt"
+export const EXTENSION_INSTALL_URL =
+  "https://extensions.gnome.org/extension/4974/window-calls-extended/"
+
+const serializeError = (error: unknown): unknown => {
+  if (error instanceof Error) {
+    return { message: error.message, name: error.name, stack: error.stack }
+  }
+  if (typeof error === "object" && error !== null) {
+    return { ...error }
+  }
+  return error
+}
+
+const isGnomeDesktop = (env: NodeJS.ProcessEnv): boolean => {
+  const desktop = env["XDG_CURRENT_DESKTOP"] ?? ""
+  return desktop.toUpperCase().includes("GNOME")
+}
+
+const isWaylandSession = (env: NodeJS.ProcessEnv): boolean => {
+  const sessionType = env["XDG_SESSION_TYPE"] ?? ""
+  if (sessionType === "wayland") return true
+  return env["WAYLAND_DISPLAY"] !== undefined && env["WAYLAND_DISPLAY"] !== ""
+}
+
+export const shouldUseWaylandGnomeProvider = (
+  env: NodeJS.ProcessEnv = process.env,
+): boolean => isWaylandSession(env) && isGnomeDesktop(env)
+
+const sessionProperty = (output: string, name: string): string => {
+  const line = output
+    .split("\n")
+    .find((candidate) => candidate.startsWith(`${name}=`))
+  return line?.slice(name.length + 1) ?? ""
+}
+
+// A systemd user service does not necessarily inherit the graphical session
+// variables. Ask logind for the user's active session before falling back.
+export const hasWaylandGnomeSession = async ({
+  env = process.env,
+  executor,
+}: {
+  readonly env?: NodeJS.ProcessEnv
+  readonly executor: CommandExecutor
+}): Promise<boolean> => {
+  if (shouldUseWaylandGnomeProvider(env)) return true
+  if (
+    env["XDG_SESSION_TYPE"] !== undefined ||
+    env["WAYLAND_DISPLAY"] !== undefined ||
+    env["DISPLAY"] !== undefined ||
+    env["XDG_CURRENT_DESKTOP"] !== undefined
+  ) {
+    return false
+  }
+  if (typeof process.getuid !== "function") return false
+
+  try {
+    const sessions = await executor.run("loginctl", [
+      "show-user",
+      String(process.getuid()),
+      "--property=Sessions",
+    ])
+    if (sessions.exitCode !== 0) return false
+    const sessionIds = sessionProperty(sessions.stdout, "Sessions")
+      .split(" ")
+      .filter((id) => id.length > 0)
+    for (const sessionId of sessionIds) {
+      const session = await executor.run("loginctl", [
+        "show-session",
+        sessionId,
+        "--property=Active",
+        "--property=Type",
+        "--property=Desktop",
+      ])
+      if (session.exitCode !== 0) continue
+      if (sessionProperty(session.stdout, "Active") !== "yes") continue
+      if (sessionProperty(session.stdout, "Type") !== "wayland") continue
+      if (
+        isGnomeDesktop({
+          XDG_CURRENT_DESKTOP: sessionProperty(session.stdout, "Desktop"),
+        })
+      )
+        return true
+
+      // Ubuntu's logind session can omit Desktop. systemd's user manager
+      // retains the graphical session variables that the daemon inherits.
+      const environment = await executor.run("systemctl", [
+        "--user",
+        "show-environment",
+      ])
+      if (
+        environment.exitCode === 0 &&
+        isGnomeDesktop({
+          XDG_CURRENT_DESKTOP: sessionProperty(
+            environment.stdout,
+            "XDG_CURRENT_DESKTOP",
+          ),
+        })
+      )
+        return true
+    }
+  } catch {
+    // No logind is available in some containers and non-Linux environments.
+  }
+  return false
+}
+
+interface ProbeResult {
+  bus: LinuxDbusBus
+  focusClass: () => Promise<string>
+  focusTitle?: () => Promise<string>
+}
+
+const probeExtension = async (
+  deps: WaylandGnomeDeps,
+): Promise<ProbeResult | null> => {
+  let bus: LinuxDbusBus | null = deps.dbus ?? null
+  if (bus === null) {
+    try {
+      bus = (await sessionBus()) as unknown as LinuxDbusBus
+    } catch (error) {
+      deps.logger.warn(
+        {
+          error: serializeError(error),
+          installUrl: EXTENSION_INSTALL_URL,
+        },
+        "active-app: GNOME session bus unavailable",
+      )
+      return null
+    }
+  }
+
+  let proxy: LinuxDbusProxyObject
+  try {
+    proxy = await Promise.race([
+      bus.getProxyObject(GNOME_SHELL_SERVICE, GNOME_EXTENSION_PATH),
+      new Promise<never>((_resolve, reject) =>
+        setTimeout(
+          () => reject(new Error("extension probe timed out")),
+          PROBE_TIMEOUT_MS,
+        ),
+      ),
+    ])
+  } catch (error) {
+    deps.logger.warn(
+      {
+        error: serializeError(error),
+        timeoutMs: PROBE_TIMEOUT_MS,
+        installUrl: EXTENSION_INSTALL_URL,
+      },
+      "active-app: GNOME extension probe failed — install 'Window Calls Extended' to enable active-app detection on Wayland",
+    )
+    bus.disconnect?.()
+    return null
+  }
+
+  const iface = proxy.getInterface(GNOME_EXTENSION_IFACE)
+  const focusClass = iface.FocusClass
+  if (typeof focusClass !== "function") {
+    deps.logger.warn(
+      { ifaceKeys: Object.keys(iface) },
+      "active-app: GNOME extension reached but FocusClass method missing",
+    )
+    bus.disconnect?.()
+    return null
+  }
+
+  const focusTitle =
+    typeof iface.FocusTitle === "function"
+      ? iface.FocusTitle.bind(iface)
+      : undefined
+
+  return {
+    bus,
+    focusClass: focusClass.bind(iface),
+    ...(focusTitle ? { focusTitle } : {}),
+  }
+}
+
+export const createWaylandGnomeProvider = async (
+  deps: WaylandGnomeDeps,
+): Promise<ActiveAppProvider> => {
+  const probe = await probeExtension(deps)
+  if (probe === null) {
+    logNull(deps.logger, "active-app", "gnome-extension-missing")
+    return {
+      async getActive() {
+        return null
+      },
+      subscribe() {
+        return () => undefined
+      },
+      async stop() {
+        return
+      },
+    }
+  }
+
+  const pollMs = deps.pollIntervalMs ?? DEFAULT_POLL_MS
+  let timer: ReturnType<typeof setTimeout> | null = null
+  let lastName: string | null = null
+  let lastTitle: string | null = null
+  let consecutiveFailures = 0
+  let stopped = false
+  const subscribers = new Set<(s: ActiveAppSnapshot | null) => void>()
+
+  const emit = (name: string | null, title: string | null): void => {
+    if (name === lastName && title === lastTitle) return
+    lastName = name
+    lastTitle = title
+    const snapshot: ActiveAppSnapshot | null =
+      name === null ? null : { name, windowTitle: title, processId: null }
+    for (const handler of subscribers) handler(snapshot)
+  }
+
+  const poll = async (): Promise<void> => {
+    if (stopped) return
+    try {
+      const [rawClass, rawTitle] = await Promise.all([
+        probe.focusClass(),
+        probe.focusTitle ? probe.focusTitle() : Promise.resolve(""),
+      ])
+      consecutiveFailures = 0
+      const name =
+        typeof rawClass === "string" && rawClass.length > 0 ? rawClass : null
+      const title =
+        typeof rawTitle === "string" && rawTitle.length > 0 ? rawTitle : null
+      emit(name, title)
+    } catch (error) {
+      consecutiveFailures += 1
+      deps.logger.debug(
+        { error: serializeError(error), consecutiveFailures },
+        "active-app: wayland-gnome poll failed",
+      )
+      if (consecutiveFailures === MAX_CONSECUTIVE_POLL_FAILURES) {
+        deps.logger.warn(
+          {
+            error: serializeError(error),
+            maxFailures: MAX_CONSECUTIVE_POLL_FAILURES,
+          },
+          "active-app: wayland-gnome poll failed repeatedly — disabling poller",
+        )
+        stopped = true
+        if (timer !== null) clearTimeout(timer)
+        return
+      }
+    }
+    if (!stopped) timer = setTimeout(() => void poll(), pollMs)
+  }
+
+  void poll()
+
+  return {
+    async getActive() {
+      return lastName === null
+        ? null
+        : { name: lastName, windowTitle: lastTitle, processId: null }
+    },
+    subscribe(handler) {
+      subscribers.add(handler)
+      const snapshot: ActiveAppSnapshot | null =
+        lastName === null
+          ? null
+          : { name: lastName, windowTitle: lastTitle, processId: null }
+      handler(snapshot)
+      return () => {
+        subscribers.delete(handler)
+      }
+    },
+    async stop() {
+      stopped = true
+      if (timer !== null) {
+        clearTimeout(timer)
+        timer = null
+      }
+      probe.bus.disconnect?.()
+    },
+  }
+}

package/src/system/providers/active-app/windows.ts

@@ -0,0 +1,94 @@
+import type pino from "pino"
+
+import type { ActiveAppProvider, ActiveAppSnapshot } from "../active-app"
+import type { CommandExecutor } from "../shared"
+
+export interface WindowsActiveAppDeps {
+  readonly executor: CommandExecutor
+  readonly logger: pino.Logger
+  readonly pollIntervalMs?: number
+}
+
+const DEFAULT_POLL_MS = 1_000
+
+const PS_GET_ACTIVE = `Add-Type -AssemblyName UIAutomationClient,UIAutomationTypes; $el=[System.Windows.Automation.AutomationElement]::FocusedElement; "{0}|{1}" -f $el.Current.Name, $el.Current.ProcessId`
+
+const parseOutput = (
+  raw: string,
+): { name: string; pid: number | null } | null => {
+  const trimmed = raw.trim()
+  if (trimmed.length === 0) return null
+  const idx = trimmed.lastIndexOf("|")
+  if (idx < 0) return null
+  const name = trimmed.substring(0, idx).trim()
+  const pidStr = trimmed.substring(idx + 1).trim()
+  const pid = Number.parseInt(pidStr, 10)
+  if (name.length === 0) return null
+  return { name, pid: Number.isFinite(pid) ? pid : null }
+}
+
+export const createWindowsActiveAppProvider = async (
+  deps: WindowsActiveAppDeps,
+): Promise<ActiveAppProvider> => {
+  const pollMs = deps.pollIntervalMs ?? DEFAULT_POLL_MS
+  const subscribers = new Set<(s: ActiveAppSnapshot | null) => void>()
+  let last: ActiveAppSnapshot | null = null
+  let stopped = false
+
+  const snapshot = async (): Promise<ActiveAppSnapshot | null> => {
+    try {
+      const result = await deps.executor.run(
+        "powershell",
+        ["-NoProfile", "-Command", PS_GET_ACTIVE],
+        { timeoutMs: 3_000 },
+      )
+      if (result.exitCode !== 0) return last
+      const parsed = parseOutput(result.stdout)
+      if (parsed === null) return last
+      return {
+        name: parsed.name,
+        windowTitle: parsed.name,
+        processId: parsed.pid,
+      }
+    } catch (err) {
+      deps.logger.warn({ err }, "active-app: powershell failed")
+      return last
+    }
+  }
+
+  let interval: ReturnType<typeof setInterval> | null = null
+  interval = setInterval(() => {
+    if (stopped) return
+    void snapshot().then((s) => {
+      if (stopped) return
+      const same =
+        last !== null &&
+        s !== null &&
+        last.name === s.name &&
+        last.processId === s.processId
+      if (!same) {
+        last = s
+        for (const h of subscribers) h(s)
+      }
+    })
+  }, pollMs)
+
+  return {
+    async getActive() {
+      return snapshot()
+    },
+    subscribe(handler) {
+      subscribers.add(handler)
+      return () => {
+        subscribers.delete(handler)
+      }
+    },
+    async stop() {
+      stopped = true
+      if (interval !== null) {
+        clearInterval(interval)
+        interval = null
+      }
+    },
+  }
+}