@ohmykreee/dsh-remote-control 0.0.0-stage → 1.0.3

package/src/dsh/lib/notifications.ts

@@ -0,0 +1,322 @@
+/**
+ * Rust-backed notification service.
+ *
+ * Windows/macOS read the OS notification database through `dsh-probe
+ * notifications`. Linux runs `dsh-probe notifications watch`, which keeps a
+ * zbus monitor of `org.freedesktop.Notifications` alive and streams a snapshot
+ * per notification. There is no PowerShell/dbus-monitor fallback.
+ */
+
+import { spawn } from 'node:child_process';
+import type { ChildProcess } from 'node:child_process';
+import * as readline from 'node:readline';
+import { probeInfo, runProbe } from './probe.js';
+import { isRecord } from './types.js';
+import type { JsonRecord, NotificationApp, NotificationItem, NotificationPayload } from './types.js';
+import { finiteNumber, safeString, serializeError } from './util.js';
+
+const POLL_TTL_MS = 2500;
+const ERROR_TTL_MS = 6000;
+const WATCH_RESTART_MS = 5000;
+
+/** Options of {@link normalizeNotificationPayload}; `limit` is clamped to 1..20. */
+export interface NotificationNormalizeOptions {
+  limit?: number;
+  /** `errorPayload` also forwards this so the Linux watcher view stays live-only. */
+  liveOnly?: boolean;
+}
+
+/** Options of {@link createNotificationService}. */
+export interface NotificationServiceOptions {
+  limit?: number;
+}
+
+/**
+ * A normalised item with every field this module populates. The shared
+ * `NotificationItem` keeps them optional because it also describes raw probe
+ * input, which is untrusted.
+ */
+interface NormalizedNotification extends NotificationItem {
+  id: string;
+  appKey: string;
+  appName: string;
+  title: string;
+  body: string;
+  avatar: string | null;
+  hasImage: boolean;
+  receivedAt: number;
+  isGroup: boolean;
+}
+
+/** Diagnostics snapshot returned by {@link NotificationService.status}. */
+export interface NotificationServiceStatus {
+  /** `undefined` only when the cached payload carries no `available` flag. */
+  available: boolean | null | undefined;
+  reason: string | null;
+  count: number | null;
+  updatedAt: number | null;
+  liveOnly?: boolean;
+}
+
+/** Host-side notification source consumed by the console service. */
+export interface NotificationService {
+  getNotifications(): Promise<NotificationPayload>;
+  status(): NotificationServiceStatus;
+  dispose(): void;
+}
+
+function normalizeAvatar(value: unknown): string | null {
+  const avatar = typeof value === 'string' ? value.trim() : '';
+  return avatar.startsWith('data:image/') ? avatar : null;
+}
+
+/**
+ * Normalize a probe notification payload into the shape the console expects.
+ * Exported for tests; the probe normally returns this shape already.
+ */
+export function normalizeNotificationPayload(
+  raw: unknown,
+  options: NotificationNormalizeOptions = {},
+): NotificationPayload {
+  const limit = Math.max(1, Math.min(20, Number(options.limit) || 8));
+  const payload: JsonRecord = isRecord(raw) ? raw : {};
+  const available = payload.available !== false && payload.ok !== false;
+  const reason = safeString(payload.reason || payload.error || '', 800) || null;
+  const source = safeString(payload.source, 120) || 'dsh-probe';
+  const list: unknown[] = Array.isArray(payload.notifications) ? payload.notifications : [];
+  const notifications: NormalizedNotification[] = [];
+  for (const item of list) {
+    if (!isRecord(item)) continue;
+    const appKey = safeString(item.appKey || item.appName, 240).trim() || 'unknown';
+    const appName = safeString(item.appName || item.appKey, 120).trim() || appKey;
+    const title = safeString(item.title || appName, 160).trim();
+    const body = safeString(item.body, 260).trim();
+    if (!title && !body) continue;
+    const receivedAt: number | null = finiteNumber(item.receivedAt, null);
+    notifications.push({
+      id: safeString(item.id, 120) || `${receivedAt ?? Date.now()}-${notifications.length}`,
+      appKey,
+      appName,
+      title,
+      body,
+      avatar: normalizeAvatar(item.avatar),
+      hasImage: Boolean(item.hasImage),
+      receivedAt: receivedAt && receivedAt > 0 ? Math.round(receivedAt) : Date.now(),
+      isGroup: Boolean(item.isGroup),
+    });
+    if (notifications.length >= limit) break;
+  }
+
+  const apps: NotificationApp[] = [];
+  const seen = new Map<string, NotificationApp>();
+  const appList: unknown[] = Array.isArray(payload.apps) ? payload.apps : [];
+  for (const app of appList) {
+    if (!isRecord(app)) continue;
+    const key = safeString(app.key, 240);
+    if (!key || seen.has(key)) continue;
+    const entry: NotificationApp = {
+      key,
+      name: safeString(app.name, 120) || key,
+      count: Math.max(0, Math.round(finiteNumber(app.count, 0) || 0)),
+    };
+    seen.set(key, entry);
+    apps.push(entry);
+  }
+  if (apps.length === 0) {
+    for (const item of notifications) {
+      const existing = seen.get(item.appKey);
+      if (existing) existing.count += 1;
+      else {
+        const entry: NotificationApp = { key: item.appKey, name: item.appName, count: 1 };
+        seen.set(item.appKey, entry);
+        apps.push(entry);
+      }
+    }
+  }
+  apps.sort((left, right) => right.count - left.count);
+
+  return {
+    ok: available,
+    available,
+    reason,
+    source,
+    liveOnly: Boolean(payload.liveOnly),
+    notifications,
+    apps,
+    updatedAt: finiteNumber(payload.updatedAt, null) || Date.now(),
+  };
+}
+
+function errorPayload(reason: unknown, extra: NotificationNormalizeOptions = {}): NotificationPayload {
+  return normalizeNotificationPayload(
+    {
+      ok: false,
+      available: false,
+      reason: serializeError(reason),
+      source: 'dsh-probe',
+      notifications: [],
+      apps: [],
+      ...extra,
+    },
+    extra,
+  );
+}
+
+export function createNotificationService(options: NotificationServiceOptions = {}): NotificationService {
+  const limit = Math.max(1, Math.min(20, Number(options.limit) || 8));
+  const watchMode = process.platform === 'linux';
+  let cache: NotificationPayload | null = null;
+  let cacheAt = 0;
+  let child: ChildProcess | null = null;
+  let lines: readline.Interface | null = null;
+  let watchState: NotificationPayload | null = null;
+  let watchError: string | null = null;
+  let watchStartedAt = 0;
+  let restartAt = 0;
+  let disposed = false;
+
+  function unavailableReason(): string | null {
+    const info = probeInfo();
+    return info.available ? null : info.error || 'native probe unavailable';
+  }
+
+  function startWatch(): void {
+    if (child || disposed) return;
+    const info = probeInfo();
+    if (!info.available) {
+      watchError = info.error || 'native probe unavailable';
+      return;
+    }
+    let spawned: ChildProcess;
+    try {
+      spawned = spawn(info.binary, ['notifications', 'watch', '--limit', String(limit)], {
+        stdio: ['ignore', 'pipe', 'pipe'],
+        windowsHide: true,
+      });
+    } catch (error) {
+      watchError = serializeError(error);
+      restartAt = Date.now() + WATCH_RESTART_MS;
+      return;
+    }
+    child = spawned;
+    watchStartedAt = Date.now();
+    watchError = null;
+    const stdout = spawned.stdout;
+    if (stdout) {
+      const stream = readline.createInterface({ input: stdout });
+      lines = stream;
+      stream.on('line', (line: string) => {
+        const text = String(line).trim();
+        if (!text.startsWith('{')) return;
+        try {
+          const parsed: unknown = JSON.parse(text);
+          const state = normalizeNotificationPayload(parsed, { limit });
+          if (state.available) {
+            watchState = state;
+            watchError = null;
+          } else {
+            watchState = null;
+            watchError = state.reason || 'notification watcher unavailable';
+          }
+        } catch {
+          /* ignore malformed lines */
+        }
+      });
+    }
+    const stderr = spawned.stderr;
+    if (stderr) {
+      stderr.setEncoding('utf8');
+      stderr.on('data', (chunk: unknown) => {
+        const text = String(chunk).trim();
+        if (text) watchError = text.slice(0, 500);
+      });
+    }
+    spawned.on('error', (error: Error) => {
+      watchError = serializeError(error);
+      watchState = null;
+    });
+    spawned.on('exit', (code: number | null, signal: NodeJS.Signals | null) => {
+      const wasStarted = Date.now() - watchStartedAt > 1000;
+      child = null;
+      watchState = null;
+      lines?.close();
+      lines = null;
+      if (disposed) return;
+      if (!watchError) {
+        watchError = `notification watcher exited (${signal || code || 'unknown'})`;
+      } else if (!wasStarted) {
+        watchError = `${watchError} (exited immediately)`;
+      }
+      restartAt = Date.now() + WATCH_RESTART_MS;
+    });
+  }
+
+  async function readOneShot(): Promise<NotificationPayload> {
+    const reason = unavailableReason();
+    if (reason) return errorPayload(reason, { limit });
+    try {
+      const raw: unknown = await runProbe(['notifications', '--limit', String(limit)], { timeout: 9000 });
+      return normalizeNotificationPayload(raw, { limit });
+    } catch (error) {
+      return errorPayload(error, { limit });
+    }
+  }
+
+  async function getNotifications(): Promise<NotificationPayload> {
+    if (!watchMode) {
+      const now = Date.now();
+      const ttl = cache?.available ? POLL_TTL_MS : ERROR_TTL_MS;
+      if (cache && now - cacheAt < ttl) return { ...cache, cached: true };
+      cache = await readOneShot();
+      cacheAt = now;
+      return cache;
+    }
+
+    if (!child && !disposed && Date.now() >= restartAt) startWatch();
+    if (watchState) {
+      return { ...watchState, cached: false };
+    }
+    const reason = watchError
+      || unavailableReason()
+      || (child ? 'notification watcher starting' : 'notification watcher unavailable');
+    return errorPayload(reason, { limit, liveOnly: true });
+  }
+
+  function status(): NotificationServiceStatus {
+    if (!watchMode) {
+      return cache
+        ? {
+            available: cache.available,
+            reason: cache.reason || null,
+            count: cache.notifications?.length ?? 0,
+            updatedAt: cache.updatedAt ?? null,
+          }
+        : { available: null, reason: null, count: null, updatedAt: null };
+    }
+    return {
+      available: watchState ? true : watchError ? false : null,
+      reason: watchError || null,
+      count: watchState?.notifications?.length ?? 0,
+      updatedAt: watchState?.updatedAt ?? null,
+      liveOnly: true,
+    };
+  }
+
+  function dispose(): void {
+    disposed = true;
+    try {
+      lines?.close();
+    } catch {
+      /* ignore */
+    }
+    lines = null;
+    try {
+      child?.kill();
+    } catch {
+      /* ignore */
+    }
+    child = null;
+  }
+
+  return { getNotifications, status, dispose };
+}

package/src/dsh/lib/performance.ts

@@ -0,0 +1,279 @@
+/**
+ * Performance view backed by `dsh-probe performance`.
+ *
+ * CPU/memory/GPU/temperatures all come from Rust. Only when the sidecar is
+ * unavailable does Node provide a pure-JS CPU/memory fallback (`os.cpus()` /
+ * `os.totalmem()`); there is no WMI or PowerShell probe left.
+ */
+
+import os from 'node:os';
+import { probeInfo, runProbe } from './probe.js';
+import { isRecord, type JsonRecord } from './types.js';
+import { clamp, finiteNumber, serializeError } from './util.js';
+
+const PROBE_ERROR_TTL_MS = 8000;
+
+/** CPU block: from Rust when the sidecar answers, otherwise from `os.cpus()`. */
+export interface PerformanceCpu {
+  usage: number;
+  model: string;
+  cores: number;
+  physicalCores: number | null;
+  speed: number | null;
+  baseSpeed: number | null;
+  uptime: number;
+  source: 'node' | 'rust';
+}
+
+/** System memory in bytes, plus the usage percentage. */
+export interface PerformanceMemory {
+  total: number;
+  used: number;
+  free: number;
+  percent: number;
+  source: 'node' | 'rust';
+}
+
+/**
+ * GPU block. `driver`, `adapters` and the memory/utilization readings are only
+ * present when the probe reported a GPU; the fallback shape carries just
+ * `name`, `ok`, `error` and `source`.
+ */
+export interface PerformanceGpu {
+  name: string;
+  ok: boolean;
+  error: string | null;
+  source: string;
+  driver?: string;
+  adapters?: unknown[];
+  utilization?: number | null;
+  memoryUsed?: number | null;
+  memoryTotal?: number | null;
+  memoryPercent?: number | null;
+  coreClockMhz?: number | null;
+  coreClockMaxMhz?: number | null;
+  memoryClockMhz?: number | null;
+  powerPercent?: number | null;
+  fanRpm?: number | null;
+}
+
+/** One temperature sensor reading in degrees Celsius. */
+export interface PerformanceTemperature {
+  name: string;
+  celsius: number;
+}
+
+/** Whether the sidecar answered, and why it did not. */
+export interface PerformanceProbeState {
+  used: boolean;
+  error: string | null;
+}
+
+/** Sampling result handed to the browser. */
+export interface PerformancePayload {
+  cpu: PerformanceCpu;
+  memory: PerformanceMemory;
+  gpu: PerformanceGpu;
+  temperatures: PerformanceTemperature[];
+  probe: PerformanceProbeState;
+  sampledAt: number;
+}
+
+/** Diagnostic snapshot returned by `status()`. */
+export interface PerformanceStatus {
+  cpu: number;
+  probeError: string | null;
+}
+
+export interface PerformanceService {
+  sample(force?: boolean): Promise<PerformancePayload>;
+  status(): PerformanceStatus;
+}
+
+function round(value: number, digits = 1): number {
+  const factor = 10 ** digits;
+  return Math.round(value * factor) / factor;
+}
+
+function cpuTimes(): { idle: number; total: number } {
+  let idle = 0;
+  let total = 0;
+  for (const cpu of os.cpus()) {
+    idle += cpu.times.idle;
+    total += cpu.times.user + cpu.times.nice + cpu.times.sys + cpu.times.idle + cpu.times.irq;
+  }
+  return { idle, total };
+}
+
+function mapProbeGpu(gpu: JsonRecord): PerformanceGpu {
+  const total = finiteNumber(gpu.memoryTotal, null);
+  const used = finiteNumber(gpu.memoryUsed, null);
+  const adapters: unknown[] = Array.isArray(gpu.adapters) ? gpu.adapters : [];
+  return {
+    name: typeof gpu.name === 'string' && gpu.name ? gpu.name : 'GPU',
+    driver: typeof gpu.driver === 'string' && gpu.driver ? gpu.driver : '',
+    adapters,
+    utilization: finiteNumber(gpu.utilization, null),
+    memoryUsed: used,
+    memoryTotal: total,
+    memoryPercent: finiteNumber(gpu.memoryPercent, null),
+    coreClockMhz: finiteNumber(gpu.coreClockMhz, null),
+    coreClockMaxMhz: finiteNumber(gpu.coreClockMaxMhz, null),
+    memoryClockMhz: finiteNumber(gpu.memoryClockMhz, null),
+    powerPercent: finiteNumber(gpu.powerPercent, null),
+    fanRpm: finiteNumber(gpu.fanRpm, null),
+    ok: gpu.ok !== false,
+    error: typeof gpu.error === 'string' && gpu.error ? gpu.error : null,
+    source: typeof gpu.source === 'string' && gpu.source ? gpu.source : 'rust',
+  };
+}
+
+export function createPerformanceService(): PerformanceService {
+  let previous = cpuTimes();
+  let cpuUsage = 0;
+  let probeError: string | null = null;
+  let probeAt = 0;
+  let inFlight: Promise<JsonRecord | null> | null = null;
+
+  function sampleNodeCpu(): PerformanceCpu {
+    const current = cpuTimes();
+    const idle = current.idle - previous.idle;
+    const total = current.total - previous.total;
+    previous = current;
+    if (total > 0) {
+      cpuUsage = clamp((1 - idle / total) * 100, 0, 100);
+    }
+    const cpus = os.cpus();
+    const baseSpeed = finiteNumber(cpus[0]?.speed, null);
+    return {
+      usage: round(cpuUsage),
+      model: cpus[0]?.model || 'CPU',
+      cores: cpus.length,
+      physicalCores: null,
+      speed: baseSpeed,
+      baseSpeed,
+      uptime: os.uptime(),
+      source: 'node',
+    };
+  }
+
+  function nodeMemory(): PerformanceMemory {
+    const total = os.totalmem();
+    const free = os.freemem();
+    return {
+      total,
+      used: total - free,
+      free,
+      percent: total ? round(((total - free) / total) * 100) : 0,
+      source: 'node',
+    };
+  }
+
+  async function readProbePerformance(): Promise<JsonRecord | null> {
+    if (!probeInfo().available) return null;
+    if (probeError && Date.now() - probeAt < PROBE_ERROR_TTL_MS) return null;
+    if (inFlight) return inFlight;
+    inFlight = (async (): Promise<JsonRecord | null> => {
+      try {
+        const raw = await runProbe(['performance'], { timeout: 12_000 });
+        const result = isRecord(raw) ? raw : null;
+        if (result && result.ok === false) {
+          const message = typeof result.error === 'string' && result.error
+            ? result.error
+            : 'dsh-probe performance failed';
+          throw new Error(message);
+        }
+        probeError = null;
+        return result;
+      } catch (error) {
+        probeError = serializeError(error);
+        probeAt = Date.now();
+        return null;
+      } finally {
+        inFlight = null;
+      }
+    })();
+    return inFlight;
+  }
+
+  async function sample(force?: boolean): Promise<PerformancePayload> {
+    const probe = await readProbePerformance();
+    const probeCpu = probe && isRecord(probe.cpu) ? probe.cpu : null;
+    const probeMemory = probe && isRecord(probe.memory) ? probe.memory : null;
+
+    const cpu: PerformanceCpu = probeCpu
+      ? {
+          usage: finiteNumber(probeCpu.usage, 0) ?? 0,
+          model: typeof probeCpu.model === 'string' && probeCpu.model ? probeCpu.model : 'CPU',
+          cores: finiteNumber(probeCpu.cores, null) || os.cpus().length,
+          physicalCores: finiteNumber(probeCpu.physicalCores, null),
+          speed: finiteNumber(probeCpu.speedMhz, null),
+          baseSpeed: finiteNumber(probeCpu.baseMhz, null),
+          uptime: finiteNumber(probeCpu.uptime, os.uptime()) ?? os.uptime(),
+          source: 'rust',
+        }
+      : sampleNodeCpu();
+
+    let memory: PerformanceMemory;
+    if (probeMemory) {
+      const total = finiteNumber(probeMemory.total, 0) ?? 0;
+      const used = finiteNumber(probeMemory.used, 0) ?? 0;
+      const free = finiteNumber(probeMemory.free, 0) ?? 0;
+      memory = {
+        total,
+        used,
+        free,
+        percent: finiteNumber(probeMemory.percent, null) ?? (total ? round((used / total) * 100) : 0),
+        source: 'rust',
+      };
+    } else {
+      memory = nodeMemory();
+    }
+
+    let gpu: PerformanceGpu;
+    const probeGpu = probe && isRecord(probe.gpu) ? probe.gpu : null;
+    if (probeGpu) {
+      gpu = mapProbeGpu(probeGpu);
+    } else {
+      gpu = {
+        name: 'GPU',
+        ok: false,
+        error: probe
+          ? '当前平台没有可用的 GPU 读数'
+          : probeInfo().error || probeError || 'native probe unavailable',
+        source: 'none',
+      };
+    }
+
+    const temperatures: PerformanceTemperature[] = [];
+    const seen = new Set<string>();
+    const candidates: unknown[] = probe && Array.isArray(probe.temperatures) ? probe.temperatures : [];
+    for (const item of candidates) {
+      const record = isRecord(item) ? item : null;
+      const value = finiteNumber(record?.celsius, null);
+      if (value === null || value < 5 || value > 125) continue;
+      const name = record && record.name ? String(record.name) : '设备';
+      const key = name.toLowerCase();
+      if (seen.has(key)) continue;
+      seen.add(key);
+      temperatures.push({ name, celsius: round(value) });
+    }
+
+    return {
+      cpu,
+      memory,
+      gpu,
+      temperatures,
+      probe: {
+        used: Boolean(probe),
+        error: probe ? null : probeInfo().error || probeError || null,
+      },
+      sampledAt: Date.now(),
+    };
+  }
+
+  return {
+    sample,
+    status: () => ({ cpu: cpuUsage, probeError }),
+  };
+}

package/src/dsh/lib/platform/index.ts

@@ -0,0 +1,43 @@
+/** Wires the Rust probe into the platform-independent service interfaces. */
+
+import { createNotificationService } from '../notifications.js';
+import { createProbeMediaAdapter } from '../probe-adapter.js';
+
+const LABELS: Record<string, string> = {
+  win32: 'Windows',
+  darwin: 'macOS',
+  linux: 'Linux',
+};
+
+export interface PlatformAdaptersOptions {
+  limit?: number;
+}
+
+export interface PlatformAdapters {
+  platform: NodeJS.Platform;
+  label: string;
+  notifications: ReturnType<typeof createNotificationService>;
+  media: ReturnType<typeof createProbeMediaAdapter>;
+  dispose(): void;
+}
+
+/**
+ * Media, volume and notifications all come from `dsh-probe`. There is no
+ * per-platform JavaScript fallback: a missing/unsupported probe is surfaced as
+ * an error payload by the adapters themselves.
+ */
+export function createPlatformAdapters(options: PlatformAdaptersOptions = {}): PlatformAdapters {
+  const platform = process.platform;
+  const label = LABELS[platform] || platform;
+  const notifications = createNotificationService({ limit: options.limit });
+  const media = createProbeMediaAdapter({ label });
+  return {
+    platform,
+    label,
+    notifications,
+    media,
+    dispose() {
+      notifications.dispose?.();
+    },
+  };
+}