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

package/src/dsh/lib/probe-adapter.ts

@@ -0,0 +1,275 @@
+/**
+ * Rust-backed media/volume adapter.
+ *
+ * `dsh-probe` is the only OS probe layer: there is no PowerShell, playerctl,
+ * wpctl or osascript fallback. When the binary is missing every read returns a
+ * clear error state and every control action throws that error.
+ *
+ * Media progress smoothing / seek eligibility lives in `media-enrich.js`.
+ */
+
+import type { JsonRecord, ProbeMediaResult, PublicMedia } from './types.js';
+import { probeInfo, materializeThumbnail, runProbe } from './probe.js';
+import { createMediaEnrichment, mediaKey } from './media-enrich.js';
+import { clamp, finiteNumber, serializeError } from './util.js';
+
+const MEDIA_TTL_MS = 1400;
+const VOLUME_TTL_MS = 3000;
+const ERROR_TTL_MS = 5000;
+const MEDIA_ACTIONS = ['playpause', 'next', 'previous', 'seek', 'like', 'volume', 'mute'];
+
+/** Cached `media read` / media action result, plus the cache-hit marker. */
+export interface MediaCache {
+  ok: boolean;
+  available: boolean;
+  media: PublicMedia | null;
+  error: string | null;
+  backend: 'rust';
+  updatedAt: number;
+  cached?: boolean;
+}
+
+/** Cached `volume read` / volume action result, plus the cache-hit marker. */
+export interface VolumeCache {
+  ok: boolean;
+  available: boolean;
+  volume: number;
+  muted: boolean;
+  error: string | null;
+  backend: 'rust';
+  updatedAt: number;
+  cached?: boolean;
+}
+
+/** One channel projected for diagnostics; every field is null before the first read. */
+interface ChannelStatus {
+  ok: boolean | null;
+  available: boolean | null;
+  error: string | null;
+  backend: 'rust' | null;
+  updatedAt: number | null;
+}
+
+export interface MediaAdapterStatus {
+  media: ChannelStatus;
+  volume: ChannelStatus;
+}
+
+/** Media plus volume snapshot handed to the browser. */
+export interface MediaStatePayload {
+  ok: boolean;
+  media: MediaCache;
+  volume: VolumeCache;
+  label: string;
+  sampledAt: number;
+}
+
+/** Result of `control('volume' | 'mute', ...)`. */
+interface VolumeControlResult {
+  ok: true;
+  action: string;
+  volume: VolumeCache;
+}
+
+/** Result of the remaining media actions. */
+interface MediaControlResult {
+  ok: true;
+  action: string;
+  media: MediaCache;
+}
+
+/** Error raised by a probe action, carrying the raw payload for diagnostics. */
+interface ProbeActionError extends Error {
+  probeResult?: JsonRecord;
+}
+
+/** The adapter surface consumed by the platform wiring and the DSH service. */
+interface ProbeMediaAdapter {
+  getState(): Promise<MediaStatePayload>;
+  getMedia(force?: boolean): Promise<MediaCache>;
+  getVolume(force?: boolean): Promise<VolumeCache>;
+  control(action: string, value?: number | boolean | null): Promise<VolumeControlResult | MediaControlResult>;
+  status(): MediaAdapterStatus;
+}
+
+function probeUnavailable(): Error {
+  const info = probeInfo();
+  return new Error(info.error || 'native probe unavailable');
+}
+
+export function createProbeMediaAdapter({ label = '平台' }: { label?: string } = {}): ProbeMediaAdapter {
+  let mediaCache: MediaCache | null = null;
+  let mediaAt = 0;
+  let volumeCache: VolumeCache | null = null;
+  let volumeAt = 0;
+  const enrichment = createMediaEnrichment();
+
+  function activeAppId(): string {
+    return mediaCache?.media?.appId || '';
+  }
+
+  async function callProbe(...args: string[]): Promise<ProbeMediaResult> {
+    const info = probeInfo();
+    if (!info.available) throw probeUnavailable();
+    const result: ProbeMediaResult = await materializeThumbnail(await runProbe(args));
+    if (result?.ok === false) {
+      const error: ProbeActionError = new Error(
+        String(result.actionError || result.error || `dsh-probe ${args.join(' ')} failed`),
+      );
+      error.probeResult = result;
+      throw error;
+    }
+    return result;
+  }
+
+  async function getMedia(force: boolean = false): Promise<MediaCache> {
+    const now = Date.now();
+    const ttl = mediaCache?.ok ? MEDIA_TTL_MS : ERROR_TTL_MS;
+    if (!force && mediaCache && now - mediaAt < ttl) return { ...mediaCache, cached: true };
+
+    try {
+      const args = ['media', 'read'];
+      const appId = activeAppId();
+      if (appId) args.push('--app-id', appId);
+      const result = await callProbe(...args);
+      mediaCache = {
+        ok: true,
+        available: result.available !== false,
+        media: await enrichment.enrich(result),
+        error: null,
+        backend: 'rust',
+        updatedAt: now,
+      };
+    } catch (error) {
+      mediaCache = {
+        ok: false,
+        available: false,
+        media: null,
+        error: serializeError(error),
+        backend: 'rust',
+        updatedAt: now,
+      };
+    }
+    mediaAt = Date.now();
+    return mediaCache;
+  }
+
+  async function getVolume(force: boolean = false): Promise<VolumeCache> {
+    const now = Date.now();
+    const ttl = volumeCache?.ok ? VOLUME_TTL_MS : ERROR_TTL_MS;
+    if (!force && volumeCache && now - volumeAt < ttl) return { ...volumeCache, cached: true };
+
+    try {
+      const result = await callProbe('volume', 'read');
+      volumeCache = {
+        ok: true,
+        available: true,
+        volume: clamp(finiteNumber(result.volume, 0.5) ?? 0.5, 0, 1),
+        muted: Boolean(result.muted),
+        error: null,
+        backend: 'rust',
+        updatedAt: now,
+      };
+    } catch (error) {
+      volumeCache = {
+        ok: false,
+        available: false,
+        volume: 0.5,
+        muted: false,
+        error: serializeError(error),
+        backend: 'rust',
+        updatedAt: now,
+      };
+    }
+    volumeAt = Date.now();
+    return volumeCache;
+  }
+
+  async function controlVolume(normalized: string, value: number | null): Promise<VolumeControlResult> {
+    const level = clamp(finiteNumber(value, 0.5) ?? 0.5, 0, 1);
+    const result = normalized === 'mute'
+      ? await callProbe('volume', 'toggle')
+      : await callProbe('volume', 'set', '--value', String(level));
+    volumeCache = {
+      ok: true,
+      available: true,
+      volume: clamp(finiteNumber(result.volume, level) ?? level, 0, 1),
+      muted: Boolean(result.muted),
+      error: null,
+      backend: 'rust',
+      updatedAt: Date.now(),
+    };
+    volumeAt = Date.now();
+    return { ok: true, action: normalized, volume: volumeCache };
+  }
+
+  async function control(
+    action: string,
+    value: number | boolean | null = null,
+  ): Promise<VolumeControlResult | MediaControlResult> {
+    const normalized = String(action || '').toLowerCase();
+    if (!MEDIA_ACTIONS.includes(normalized)) throw new Error('Unsupported media action');
+    if (normalized === 'volume' || normalized === 'mute') {
+      return controlVolume(normalized, Number(value));
+    }
+    if (normalized === 'like' && !mediaCache?.media?.canSetLiked) {
+      throw new Error('当前播放器不支持修改红心');
+    }
+
+    let position = 0;
+    if (normalized === 'seek') {
+      if (!mediaCache?.media?.canSeek) throw new Error('当前播放器只上报进度，不支持拖动');
+      position = clamp(finiteNumber(value, 0) ?? 0, 0, 24 * 60 * 60);
+    }
+
+    if (normalized === 'seek') enrichment.markSeek(mediaKey(mediaCache?.media), position);
+    const args = ['media', normalized];
+    if (normalized === 'seek') args.push('--position', String(position));
+    if (normalized === 'like' && typeof value === 'boolean') {
+      args.push('--value', value ? 'true' : 'false');
+    }
+    const appId = activeAppId();
+    if (appId) args.push('--app-id', appId);
+    const result = await callProbe(...args);
+    mediaCache = {
+      ok: true,
+      available: result.available !== false,
+      media: await enrichment.enrich(result),
+      error: null,
+      backend: 'rust',
+      updatedAt: Date.now(),
+    };
+    mediaAt = Date.now();
+    return { ok: true, action: normalized, media: mediaCache };
+  }
+
+  async function getState(): Promise<MediaStatePayload> {
+    const [media, volume] = await Promise.all([getMedia(), getVolume()]);
+    return { ok: media.ok || volume.ok, media, volume, label, sampledAt: Date.now() };
+  }
+
+  function status(): MediaAdapterStatus {
+    return {
+      media: mediaCache
+        ? {
+            ok: mediaCache.ok,
+            available: mediaCache.available,
+            error: mediaCache.error,
+            backend: mediaCache.backend,
+            updatedAt: mediaCache.updatedAt,
+          }
+        : { ok: null, available: null, error: null, backend: null, updatedAt: null },
+      volume: volumeCache
+        ? {
+            ok: volumeCache.ok,
+            available: volumeCache.available,
+            error: volumeCache.error,
+            backend: volumeCache.backend,
+            updatedAt: volumeCache.updatedAt,
+          }
+        : { ok: null, available: null, error: null, backend: null, updatedAt: null },
+    };
+  }
+
+  return { getState, getMedia, getVolume, control, status };
+}

package/src/dsh/lib/probe-daemon.ts

@@ -0,0 +1,359 @@
+/**
+ * Persistent `dsh-probe daemon` client.
+ *
+ * Starting the native probe for every poll costs process creation plus a full
+ * platform sampler warm-up (sysinfo's CPU window, PDH query setup, D-Bus
+ * connect, WinRT initialization). This client keeps one daemon process alive
+ * and multiplexes requests over newline-delimited JSON on stdin/stdout.
+ *
+ * The daemon is demand-driven: it only samples when a request arrives, so an
+ * idle console costs one sleeping process and no periodic wake-ups. It exits
+ * after `IDLE_TIMEOUT_MS` without requests, and the next request starts a fresh
+ * one. If the binary predates daemon support, `probe.ts` falls back to one-shot
+ * invocations for a while instead of failing the feature.
+ */
+
+import { spawn, type ChildProcessWithoutNullStreams } from 'node:child_process';
+import { createInterface, type Interface } from 'node:readline';
+import type { JsonRecord } from './types.js';
+import { isRecord } from './types.js';
+
+/** Must match `daemon::PROTOCOL_VERSION` in the Rust probe. */
+export const DAEMON_PROTOCOL_VERSION = 1;
+
+const READY_TIMEOUT_MS = 10_000;
+const DEFAULT_IDLE_TIMEOUT_MS = 60_000;
+const MAX_STDERR = 4_000;
+
+/** The daemon could not be started; the caller may retry with one-shot mode. */
+export class ProbeDaemonStartError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'ProbeDaemonStartError';
+  }
+}
+
+interface PendingRequest {
+  resolve: (value: JsonRecord) => void;
+  reject: (error: Error) => void;
+  timer: NodeJS.Timeout;
+}
+
+interface ReadyGate {
+  resolve: () => void;
+  reject: (error: Error) => void;
+  timer: NodeJS.Timeout;
+}
+
+function idleTimeoutMs(): number {
+  const raw = Number(process.env.DSH_RC_PROBE_DAEMON_IDLE_MS);
+  if (!Number.isFinite(raw) || raw < 5_000) return DEFAULT_IDLE_TIMEOUT_MS;
+  return Math.min(raw, 30 * 60_000);
+}
+
+export class ProbeDaemonClient {
+  private readonly binary: string;
+  private readonly env: NodeJS.ProcessEnv;
+  private child: ChildProcessWithoutNullStreams | null = null;
+  private reader: Interface | null = null;
+  private readyGate: ReadyGate | null = null;
+  private ready = false;
+  private starting: Promise<void> | null = null;
+  private pending = new Map<number, PendingRequest>();
+  private nextId = 1;
+  private stderr = '';
+  private idleTimer: NodeJS.Timeout | null = null;
+  private stopped = false;
+
+  constructor(binary: string, env: NodeJS.ProcessEnv = process.env) {
+    this.binary = binary;
+    this.env = env;
+  }
+
+  isRunning(): boolean {
+    return this.ready && this.child !== null;
+  }
+
+  /** Run one probe command through the daemon, starting it on demand. */
+  async request(argv: string[], timeoutMs: number): Promise<JsonRecord> {
+    if (!this.ready || !this.child) await this.ensureStarted();
+    const child = this.child;
+    if (!child || !this.ready) throw new ProbeDaemonStartError('probe daemon is not running');
+    if (child.stdin.destroyed) throw new ProbeDaemonStartError('probe daemon stdin is closed');
+
+    const id = this.nextId++;
+    const payload = `${JSON.stringify({ id, argv })}\n`;
+    const timeout = Math.max(1_000, Math.min(Number(timeoutMs) || 15_000, 60_000));
+
+    return new Promise<JsonRecord>((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        this.fail(new Error(`dsh-probe daemon ${argv.join(' ')} timed out after ${timeout} ms`));
+      }, timeout);
+      timer.unref?.();
+      this.pending.set(id, { resolve, reject, timer });
+      this.armIdle();
+
+      child.stdin.write(payload, (error) => {
+        if (!error) return;
+        const pending = this.pending.get(id);
+        if (!pending) return;
+        this.pending.delete(id);
+        clearTimeout(pending.timer);
+        pending.reject(error);
+      });
+    });
+  }
+
+  /** Stop the daemon and reject anything still in flight. */
+  shutdown(): void {
+    this.stopped = true;
+    this.clearIdle();
+    const error = new Error('probe daemon shut down');
+    this.rejectAll(error);
+    const gate = this.readyGate;
+    this.readyGate = null;
+    if (gate) {
+      clearTimeout(gate.timer);
+      gate.reject(new ProbeDaemonStartError(error.message));
+    }
+    const child = this.child;
+    this.child = null;
+    this.ready = false;
+    this.reader?.close();
+    this.reader = null;
+    if (child) {
+      try {
+        child.stdin.end();
+      } catch {
+        /* already closed */
+      }
+      try {
+        child.kill();
+      } catch {
+        /* already exited */
+      }
+    }
+  }
+
+  /** Synchronous best-effort kill for a process-exit hook. */
+  kill(): void {
+    const child = this.child;
+    this.child = null;
+    this.ready = false;
+    if (!child) return;
+    try {
+      child.kill();
+    } catch {
+      /* already exited */
+    }
+  }
+
+  private ensureStarted(): Promise<void> {
+    if (this.ready && this.child) return Promise.resolve();
+    if (this.starting) return this.starting;
+    this.starting = this.start().finally(() => {
+      this.starting = null;
+    });
+    return this.starting;
+  }
+
+  private start(): Promise<void> {
+    return new Promise<void>((resolve, reject) => {
+      let child: ChildProcessWithoutNullStreams;
+      try {
+        child = spawn(this.binary, ['daemon'], {
+          stdio: ['pipe', 'pipe', 'pipe'],
+          windowsHide: true,
+          env: this.env,
+        });
+      } catch (error) {
+        reject(new ProbeDaemonStartError(`failed to start dsh-probe daemon: ${String(error)}`));
+        return;
+      }
+
+      this.child = child;
+      this.ready = false;
+      this.stderr = '';
+      this.stopped = false;
+
+      const timer = setTimeout(() => {
+        this.readyGate = null;
+        this.stopChild(child);
+        reject(new ProbeDaemonStartError(`dsh-probe daemon did not become ready within ${READY_TIMEOUT_MS} ms`));
+      }, READY_TIMEOUT_MS);
+      timer.unref?.();
+      this.readyGate = { resolve, reject, timer };
+
+      child.stderr.setEncoding('utf8');
+      child.stderr.on('data', (chunk: string) => {
+        this.stderr = (this.stderr + chunk).slice(-MAX_STDERR);
+      });
+      child.once('error', (error) => {
+        if (this.child !== child) return;
+        this.failStart(child, new ProbeDaemonStartError(`failed to start dsh-probe daemon: ${error.message}`));
+      });
+      child.once('exit', (code, signal) => {
+        this.handleExit(child, code, signal);
+      });
+
+      const reader = createInterface({ input: child.stdout, crlfDelay: Infinity });
+      this.reader = reader;
+      reader.on('line', (line) => {
+        this.handleLine(line);
+      });
+      reader.on('close', () => {
+        /* the exit handler owns cleanup */
+      });
+    });
+  }
+
+  private handleLine(line: string): void {
+    const text = line.trim();
+    if (!text) return;
+    let message: unknown;
+    try {
+      message = JSON.parse(text);
+    } catch {
+      return;
+    }
+    if (!isRecord(message)) return;
+
+    if (message.event === 'ready') {
+      if (this.ready) return;
+      const protocol = Number(message.protocol);
+      if (protocol !== DAEMON_PROTOCOL_VERSION) {
+        this.failStart(
+          this.child,
+          new ProbeDaemonStartError(
+            `dsh-probe daemon protocol ${String(message.protocol)} is not supported (expected ${DAEMON_PROTOCOL_VERSION})`,
+          ),
+        );
+        return;
+      }
+      this.ready = true;
+      const gate = this.readyGate;
+      this.readyGate = null;
+      if (gate) {
+        clearTimeout(gate.timer);
+        gate.resolve();
+      }
+      this.armIdle();
+      return;
+    }
+
+    const id = typeof message.id === 'number' ? message.id : null;
+    if (id === null) return;
+    const pending = this.pending.get(id);
+    if (!pending) return;
+    this.pending.delete(id);
+    clearTimeout(pending.timer);
+    this.armIdle();
+
+    if (message.ok !== true) {
+      pending.reject(new Error(typeof message.error === 'string' ? message.error : 'dsh-probe daemon request failed'));
+      return;
+    }
+    if (!isRecord(message.result)) {
+      pending.reject(new Error('dsh-probe daemon returned no result payload'));
+      return;
+    }
+    pending.resolve(message.result);
+  }
+
+  private handleExit(
+    child: ChildProcessWithoutNullStreams,
+    code: number | null,
+    signal: NodeJS.Signals | null,
+  ): void {
+    if (this.child !== child) return;
+    this.child = null;
+    this.ready = false;
+    this.reader?.close();
+    this.reader = null;
+    this.clearIdle();
+
+    const detail = [
+      code === null ? '' : `code ${code}`,
+      signal ? `signal ${signal}` : '',
+      this.stderr.trim(),
+    ]
+      .filter(Boolean)
+      .join(', ');
+    const message = `dsh-probe daemon exited${detail ? ` (${detail})` : ''}`;
+
+    const gate = this.readyGate;
+    this.readyGate = null;
+    if (gate) {
+      clearTimeout(gate.timer);
+      gate.reject(new ProbeDaemonStartError(message));
+    }
+    this.rejectAll(new Error(message));
+  }
+
+  private failStart(child: ChildProcessWithoutNullStreams | null, error: ProbeDaemonStartError): void {
+    const gate = this.readyGate;
+    this.readyGate = null;
+    if (gate) {
+      clearTimeout(gate.timer);
+      gate.reject(error);
+    }
+    this.rejectAll(error);
+    if (child) this.stopChild(child);
+  }
+
+  private fail(error: Error): void {
+    this.rejectAll(error);
+    const child = this.child;
+    this.child = null;
+    this.ready = false;
+    if (child) this.stopChild(child);
+  }
+
+  private stopChild(child: ChildProcessWithoutNullStreams): void {
+    if (this.child === child) {
+      this.child = null;
+      this.ready = false;
+    }
+    this.reader?.close();
+    this.reader = null;
+    try {
+      child.stdin.end();
+    } catch {
+      /* already closed */
+    }
+    try {
+      child.kill();
+    } catch {
+      /* already exited */
+    }
+  }
+
+  private rejectAll(error: Error): void {
+    for (const pending of this.pending.values()) {
+      clearTimeout(pending.timer);
+      pending.reject(error);
+    }
+    this.pending.clear();
+  }
+
+  private armIdle(): void {
+    this.clearIdle();
+    if (this.stopped || !this.ready) return;
+    this.idleTimer = setTimeout(() => {
+      this.idleTimer = null;
+      if (this.pending.size > 0) {
+        this.armIdle();
+        return;
+      }
+      this.shutdown();
+    }, idleTimeoutMs());
+    this.idleTimer.unref?.();
+  }
+
+  private clearIdle(): void {
+    if (!this.idleTimer) return;
+    clearTimeout(this.idleTimer);
+    this.idleTimer = null;
+  }
+}