lightman-agent 1.0.18 → 1.0.21

package/src/lib/screenMap.ts

@@ -0,0 +1,135 @@
+import type { DetectedScreen } from './screens.js';
+import type { ScreenMapping } from './types.js';
+
+export type ScreenMapMode = 'none' | 'explicit' | 'explicit+autofill' | 'auto';
+
+export interface ResolveScreenMapInput {
+  requestedScreenMap: ScreenMapping[];
+  detectedScreens: DetectedScreen[];
+  totalScreens?: number;
+}
+
+export interface ResolveScreenMapResult {
+  screenMap: ScreenMapping[];
+  mode: ScreenMapMode;
+}
+
+export function resolveScreenMap(input: ResolveScreenMapInput): ResolveScreenMapResult {
+  const requested = (input.requestedScreenMap || []).map((m) => ({
+    hardwareId: String(m.hardwareId || '').trim(),
+    url: String(m.url || ''),
+    label: m.label,
+  }));
+  const detected = [...(input.detectedScreens || [])].sort((a, b) => a.index - b.index);
+  const targetCount = Math.max(requested.length, normalizePositiveInt(input.totalScreens));
+
+  if (targetCount === 0) {
+    return { screenMap: [], mode: 'none' };
+  }
+
+  const explicitByIndex = new Map<number, string>();
+  const reservedForExplicit = new Set<string>();
+  for (let idx = 0; idx < targetCount; idx++) {
+    const requestedId = requested[idx]?.hardwareId || '';
+    if (!requestedId) continue;
+    const resolved = resolveDetectedScreen(requestedId, detected);
+    if (!resolved) continue;
+    const key = toKey(resolved.hardwareId);
+    if (reservedForExplicit.has(key)) continue;
+    explicitByIndex.set(idx, resolved.hardwareId);
+    reservedForExplicit.add(key);
+  }
+
+  const used = new Set<string>();
+  const screenMap: ScreenMapping[] = [];
+  let explicitEntries = 0;
+  let autofilledEntries = 0;
+
+  for (let idx = 0; idx < targetCount; idx++) {
+    const requestedEntry = requested[idx];
+    const requestedId = requestedEntry?.hardwareId || '';
+    const requestedUrl = requestedEntry?.url || '';
+    const requestedLabel = requestedEntry?.label;
+
+    let finalHardwareId = requestedId;
+    const explicitResolved = explicitByIndex.get(idx);
+    if (explicitResolved) {
+      explicitEntries++;
+      finalHardwareId = explicitResolved;
+    } else if (requestedId) {
+      explicitEntries++;
+      const fallbackPreferred = detected.find((s) => (
+        !used.has(toKey(s.hardwareId)) && !reservedForExplicit.has(toKey(s.hardwareId))
+      ));
+      const fallbackAny = fallbackPreferred || detected.find((s) => !used.has(toKey(s.hardwareId)));
+      if (fallbackAny) {
+        finalHardwareId = fallbackAny.hardwareId;
+        autofilledEntries++;
+      }
+    } else {
+      const fallbackPreferred = detected.find((s) => (
+        !used.has(toKey(s.hardwareId)) && !reservedForExplicit.has(toKey(s.hardwareId))
+      ));
+      const fallbackAny = fallbackPreferred || detected.find((s) => !used.has(toKey(s.hardwareId)));
+      if (fallbackAny) {
+        finalHardwareId = fallbackAny.hardwareId;
+        autofilledEntries++;
+      } else {
+        finalHardwareId = '';
+      }
+    }
+
+    if (finalHardwareId) {
+      used.add(toKey(finalHardwareId));
+    }
+
+    const entry: ScreenMapping = {
+      hardwareId: finalHardwareId,
+      url: requestedUrl,
+    };
+    if (requestedLabel) {
+      entry.label = requestedLabel;
+    }
+    screenMap.push(entry);
+  }
+
+  return {
+    screenMap,
+    mode: inferMode(explicitEntries, autofilledEntries),
+  };
+}
+
+export function resolveDetectedScreen(id: string, detectedScreens: DetectedScreen[]): DetectedScreen | undefined {
+  const requested = String(id || '').trim();
+  if (!requested) return undefined;
+
+  const direct = detectedScreens.find((s) => toKey(s.hardwareId) === toKey(requested));
+  if (direct) return direct;
+
+  if (/^\d+$/.test(requested)) {
+    const suffix = 'DISPLAY' + requested;
+    return detectedScreens.find((s) => {
+      const hw = s.hardwareId.toUpperCase();
+      return hw.endsWith(suffix) && (hw.length === suffix.length || hw[hw.length - suffix.length - 1] === '\\');
+    });
+  }
+
+  return undefined;
+}
+
+function normalizePositiveInt(value: number | undefined): number {
+  if (typeof value !== 'number' || !Number.isFinite(value)) return 0;
+  const n = Math.floor(value);
+  return n > 0 ? n : 0;
+}
+
+function inferMode(explicitEntries: number, autofilledEntries: number): ScreenMapMode {
+  if (explicitEntries === 0 && autofilledEntries === 0) return 'none';
+  if (explicitEntries === 0 && autofilledEntries > 0) return 'auto';
+  if (autofilledEntries > 0) return 'explicit+autofill';
+  return 'explicit';
+}
+
+function toKey(hardwareId: string): string {
+  return hardwareId.toUpperCase();
+}

package/src/lib/screens.ts

@@ -1,128 +1,128 @@
-import { execSync } from 'child_process';
-import { getPlatform } from './platform.js';
-import type { Logger } from './logger.js';
-
-export interface DetectedScreen {
-  /** Windows display device ID, e.g. "\\.\DISPLAY1" */
-  hardwareId: string;
-  /** Friendly name / adapter description */
-  name: string;
-  /** Display index (0-based) */
-  index: number;
-  /** Screen bounds */
-  x: number;
-  y: number;
-  width: number;
-  height: number;
-  /** Whether this is the primary monitor */
-  primary: boolean;
-}
-
-/**
- * Detect all connected displays on this machine.
- * Windows: uses PowerShell + CIM to get monitor positions and IDs.
- * Linux/macOS: uses xrandr / system_profiler (basic fallback).
- */
-export function detectScreens(logger: Logger): DetectedScreen[] {
-  const platform = getPlatform();
-
-  if (platform === 'windows') {
-    return detectScreensWindows(logger);
-  }
-
-  if (platform === 'linux') {
-    return detectScreensLinux(logger);
-  }
-
-  logger.warn('[Screens] Screen detection not supported on this platform');
-  return [];
-}
-
-function detectScreensWindows(logger: Logger): DetectedScreen[] {
-  try {
-    // PowerShell script — use regular string to avoid JS template literal eating $variables
-    const psScript = [
-      'Add-Type -AssemblyName System.Windows.Forms;',
-      '$screens = [System.Windows.Forms.Screen]::AllScreens;',
-      '$result = @();',
-      '$i = 0;',
-      'foreach ($s in $screens) {',
-      '  $result += [PSCustomObject]@{',
-      '    hardwareId = $s.DeviceName;',
-      '    name = $s.DeviceName;',
-      '    index = $i;',
-      '    x = $s.Bounds.X;',
-      '    y = $s.Bounds.Y;',
-      '    width = $s.Bounds.Width;',
-      '    height = $s.Bounds.Height;',
-      '    primary = $s.Primary',
-      '  };',
-      '  $i++',
-      '};',
-      '$result | ConvertTo-Json -Compress',
-    ].join(' ');
-
-    const result = execSync('powershell -NoProfile -Command "' + psScript + '"', {
-      encoding: 'utf-8',
-      timeout: 10_000,
-      stdio: ['pipe', 'pipe', 'ignore'],
-    }).trim();
-
-    if (!result) {
-      logger.warn('[Screens] PowerShell returned empty result');
-      return [];
-    }
-
-    // PowerShell returns a single object (not array) when there's only 1 screen
-    const parsed = JSON.parse(result);
-    const screens: DetectedScreen[] = Array.isArray(parsed) ? parsed : [parsed];
-
-    logger.info(`[Screens] Detected ${screens.length} display(s)`);
-    for (const s of screens) {
-      logger.debug(`[Screens]   ${s.hardwareId} — ${s.width}x${s.height} @ (${s.x},${s.y})${s.primary ? ' [PRIMARY]' : ''}`);
-    }
-
-    return screens;
-  } catch (err) {
-    logger.error('[Screens] Failed to detect screens on Windows:', err instanceof Error ? err.message : String(err));
-    return [];
-  }
-}
-
-function detectScreensLinux(logger: Logger): DetectedScreen[] {
-  try {
-    const result = execSync('xrandr --query', {
-      encoding: 'utf-8',
-      timeout: 5_000,
-      stdio: ['pipe', 'pipe', 'ignore'],
-    });
-
-    const screens: DetectedScreen[] = [];
-    const lines = result.split('\n');
-    let index = 0;
-
-    for (const line of lines) {
-      // Match lines like: "HDMI-1 connected primary 1920x1080+0+0"
-      const match = line.match(/^(\S+)\s+connected\s+(primary\s+)?(\d+)x(\d+)\+(\d+)\+(\d+)/);
-      if (match) {
-        screens.push({
-          hardwareId: match[1],
-          name: match[1],
-          index,
-          x: parseInt(match[5], 10),
-          y: parseInt(match[6], 10),
-          width: parseInt(match[3], 10),
-          height: parseInt(match[4], 10),
-          primary: !!match[2],
-        });
-        index++;
-      }
-    }
-
-    logger.info(`[Screens] Detected ${screens.length} display(s) via xrandr`);
-    return screens;
-  } catch (err) {
-    logger.error('[Screens] Failed to detect screens on Linux:', err instanceof Error ? err.message : String(err));
-    return [];
-  }
-}
+import { execSync } from 'child_process';
+import { getPlatform } from './platform.js';
+import type { Logger } from './logger.js';
+
+export interface DetectedScreen {
+  /** Windows display device ID, e.g. "\\.\DISPLAY1" */
+  hardwareId: string;
+  /** Friendly name / adapter description */
+  name: string;
+  /** Display index (0-based) */
+  index: number;
+  /** Screen bounds */
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+  /** Whether this is the primary monitor */
+  primary: boolean;
+}
+
+/**
+ * Detect all connected displays on this machine.
+ * Windows: uses PowerShell + CIM to get monitor positions and IDs.
+ * Linux/macOS: uses xrandr / system_profiler (basic fallback).
+ */
+export function detectScreens(logger: Logger): DetectedScreen[] {
+  const platform = getPlatform();
+
+  if (platform === 'windows') {
+    return detectScreensWindows(logger);
+  }
+
+  if (platform === 'linux') {
+    return detectScreensLinux(logger);
+  }
+
+  logger.warn('[Screens] Screen detection not supported on this platform');
+  return [];
+}
+
+function detectScreensWindows(logger: Logger): DetectedScreen[] {
+  try {
+    // PowerShell script — use regular string to avoid JS template literal eating $variables
+    const psScript = [
+      'Add-Type -AssemblyName System.Windows.Forms;',
+      '$screens = [System.Windows.Forms.Screen]::AllScreens;',
+      '$result = @();',
+      '$i = 0;',
+      'foreach ($s in $screens) {',
+      '  $result += [PSCustomObject]@{',
+      '    hardwareId = $s.DeviceName;',
+      '    name = $s.DeviceName;',
+      '    index = $i;',
+      '    x = $s.Bounds.X;',
+      '    y = $s.Bounds.Y;',
+      '    width = $s.Bounds.Width;',
+      '    height = $s.Bounds.Height;',
+      '    primary = $s.Primary',
+      '  };',
+      '  $i++',
+      '};',
+      '$result | ConvertTo-Json -Compress',
+    ].join(' ');
+
+    const result = execSync('powershell -NoProfile -Command "' + psScript + '"', {
+      encoding: 'utf-8',
+      timeout: 10_000,
+      stdio: ['pipe', 'pipe', 'ignore'],
+    }).trim();
+
+    if (!result) {
+      logger.warn('[Screens] PowerShell returned empty result');
+      return [];
+    }
+
+    // PowerShell returns a single object (not array) when there's only 1 screen
+    const parsed = JSON.parse(result);
+    const screens: DetectedScreen[] = Array.isArray(parsed) ? parsed : [parsed];
+
+    logger.info(`[Screens] Detected ${screens.length} display(s)`);
+    for (const s of screens) {
+      logger.debug(`[Screens]   ${s.hardwareId} — ${s.width}x${s.height} @ (${s.x},${s.y})${s.primary ? ' [PRIMARY]' : ''}`);
+    }
+
+    return screens;
+  } catch (err) {
+    logger.error('[Screens] Failed to detect screens on Windows:', err instanceof Error ? err.message : String(err));
+    return [];
+  }
+}
+
+function detectScreensLinux(logger: Logger): DetectedScreen[] {
+  try {
+    const result = execSync('xrandr --query', {
+      encoding: 'utf-8',
+      timeout: 5_000,
+      stdio: ['pipe', 'pipe', 'ignore'],
+    });
+
+    const screens: DetectedScreen[] = [];
+    const lines = result.split('\n');
+    let index = 0;
+
+    for (const line of lines) {
+      // Match lines like: "HDMI-1 connected primary 1920x1080+0+0"
+      const match = line.match(/^(\S+)\s+connected\s+(primary\s+)?(\d+)x(\d+)\+(\d+)\+(\d+)/);
+      if (match) {
+        screens.push({
+          hardwareId: match[1],
+          name: match[1],
+          index,
+          x: parseInt(match[5], 10),
+          y: parseInt(match[6], 10),
+          width: parseInt(match[3], 10),
+          height: parseInt(match[4], 10),
+          primary: !!match[2],
+        });
+        index++;
+      }
+    }
+
+    logger.info(`[Screens] Detected ${screens.length} display(s) via xrandr`);
+    return screens;
+  } catch (err) {
+    logger.error('[Screens] Failed to detect screens on Linux:', err instanceof Error ? err.message : String(err));
+    return [];
+  }
+}