lightman-agent 1.0.12 → 1.0.14

package/src/lib/config.ts

@@ -1,90 +1,69 @@
-import { readFileSync, existsSync } from 'fs';
-import { resolve } from 'path';
-import { z } from 'zod';
-import type { AgentConfig } from './types.js';
-
-export function getDefaultKioskBrowserPath(): string {
-  if (process.platform === 'win32') {
-    const candidates = [
-      'C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe',
-      'C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe',
-      'C:\\Program Files\\Microsoft\\Edge\\Application\\msedge.exe',
-      'C:\\Program Files (x86)\\Microsoft\\Edge\\Application\\msedge.exe',
-    ];
-
-    for (const candidate of candidates) {
-      if (existsSync(candidate)) {
-        return candidate;
-      }
-    }
-
-    return 'C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe';
-  }
-
-  return 'chromium-browser';
-}
-
-const kioskSchema = z.object({
-  browserPath: z.string().default(getDefaultKioskBrowserPath()),
-  defaultUrl: z.string().url().default('http://localhost:3401/display'),
-  extraArgs: z.array(z.string()).default([]),
-  pollIntervalMs: z.number().int().min(1000).default(10_000),
-  maxCrashesInWindow: z.number().int().min(1).default(10),
-  crashWindowMs: z.number().int().min(10_000).default(300_000),
-  shellMode: z.boolean().default(false),
-});
-
-const screenshotSchema = z.object({
-  captureCommand: z.string().default('scrot'),
-  quality: z.number().int().min(1).max(100).default(80),
-  uploadEndpoint: z.string().default('/api/devices/{deviceId}/screenshot'),
-});
-
-const powerScheduleSchema = z.object({
-  shutdownCron: z.string().optional(),
-  startupCron: z.string().optional(),
-  timezone: z.string().default(Intl.DateTimeFormat().resolvedOptions().timeZone),
-  shutdownWarningSeconds: z.number().int().min(0).max(600).default(60),
-});
-
-const configSchema = z.object({
-  serverUrl: z.string().url(),
-  deviceSlug: z.string().min(1),
-  healthIntervalMs: z.number().int().min(5000).default(60000),
-  logLevel: z.enum(['debug', 'info', 'warn', 'error']).default('info'),
-  logFile: z.string().default('agent.log'),
-  identityFile: z.string().default('.lightman-identity.json'),
-  localServices: z.boolean().default(true),
-  kiosk: kioskSchema.optional(),
-  screenshot: screenshotSchema.optional(),
-  powerSchedule: powerScheduleSchema.optional(),
-});
-
-export function loadConfig(configPath?: string): AgentConfig {
-  const filePath = configPath || resolve(process.cwd(), 'agent.config.json');
-
-  if (!existsSync(filePath)) {
-    throw new Error(`Config file not found: ${filePath}`);
-  }
-
-  let raw: Record<string, unknown>;
-  try {
-    raw = JSON.parse(readFileSync(filePath, 'utf-8'));
-  } catch (err) {
-    throw new Error(`Invalid JSON in config file ${filePath}: ${err instanceof Error ? err.message : String(err)}`);
-  }
-
-  // Apply environment overrides
-  const merged = {
-    ...raw,
-    ...(process.env.LIGHTMAN_SERVER_URL && { serverUrl: process.env.LIGHTMAN_SERVER_URL }),
-    ...(process.env.LIGHTMAN_DEVICE_SLUG && { deviceSlug: process.env.LIGHTMAN_DEVICE_SLUG }),
-    ...(process.env.LIGHTMAN_HEALTH_INTERVAL && { healthIntervalMs: parseInt(process.env.LIGHTMAN_HEALTH_INTERVAL, 10) }),
-    ...(process.env.LIGHTMAN_LOG_LEVEL && { logLevel: process.env.LIGHTMAN_LOG_LEVEL }),
-    ...(process.env.LIGHTMAN_LOG_FILE && { logFile: process.env.LIGHTMAN_LOG_FILE }),
-    ...(process.env.LIGHTMAN_IDENTITY_FILE && { identityFile: process.env.LIGHTMAN_IDENTITY_FILE }),
-  };
-
-  const result = configSchema.parse(merged);
-  return result as AgentConfig;
-}
+import { readFileSync, existsSync } from 'fs';
+import { resolve } from 'path';
+import { z } from 'zod';
+import type { AgentConfig } from './types.js';
+
+const kioskSchema = z.object({
+  browserPath: z.string().default('chromium-browser'),
+  defaultUrl: z.string().url().default('http://localhost:3401/display'),
+  extraArgs: z.array(z.string()).default([]),
+  pollIntervalMs: z.number().int().min(1000).default(10_000),
+  maxCrashesInWindow: z.number().int().min(1).default(10),
+  crashWindowMs: z.number().int().min(10_000).default(300_000),
+  shellMode: z.boolean().default(false),
+});
+
+const screenshotSchema = z.object({
+  captureCommand: z.string().default('scrot'),
+  quality: z.number().int().min(1).max(100).default(80),
+  uploadEndpoint: z.string().default('/api/devices/{deviceId}/screenshot'),
+});
+
+const powerScheduleSchema = z.object({
+  shutdownCron: z.string().optional(),
+  startupCron: z.string().optional(),
+  timezone: z.string().default(Intl.DateTimeFormat().resolvedOptions().timeZone),
+  shutdownWarningSeconds: z.number().int().min(0).max(600).default(60),
+});
+
+const configSchema = z.object({
+  serverUrl: z.string().url(),
+  deviceSlug: z.string().min(1),
+  healthIntervalMs: z.number().int().min(5000).default(60000),
+  logLevel: z.enum(['debug', 'info', 'warn', 'error']).default('info'),
+  logFile: z.string().default('agent.log'),
+  identityFile: z.string().default('.lightman-identity.json'),
+  localServices: z.boolean().default(true),
+  kiosk: kioskSchema.optional(),
+  screenshot: screenshotSchema.optional(),
+  powerSchedule: powerScheduleSchema.optional(),
+});
+
+export function loadConfig(configPath?: string): AgentConfig {
+  const filePath = configPath || resolve(process.cwd(), 'agent.config.json');
+
+  if (!existsSync(filePath)) {
+    throw new Error(`Config file not found: ${filePath}`);
+  }
+
+  let raw: Record<string, unknown>;
+  try {
+    raw = JSON.parse(readFileSync(filePath, 'utf-8'));
+  } catch (err) {
+    throw new Error(`Invalid JSON in config file ${filePath}: ${err instanceof Error ? err.message : String(err)}`);
+  }
+
+  // Apply environment overrides
+  const merged = {
+    ...raw,
+    ...(process.env.LIGHTMAN_SERVER_URL && { serverUrl: process.env.LIGHTMAN_SERVER_URL }),
+    ...(process.env.LIGHTMAN_DEVICE_SLUG && { deviceSlug: process.env.LIGHTMAN_DEVICE_SLUG }),
+    ...(process.env.LIGHTMAN_HEALTH_INTERVAL && { healthIntervalMs: parseInt(process.env.LIGHTMAN_HEALTH_INTERVAL, 10) }),
+    ...(process.env.LIGHTMAN_LOG_LEVEL && { logLevel: process.env.LIGHTMAN_LOG_LEVEL }),
+    ...(process.env.LIGHTMAN_LOG_FILE && { logFile: process.env.LIGHTMAN_LOG_FILE }),
+    ...(process.env.LIGHTMAN_IDENTITY_FILE && { identityFile: process.env.LIGHTMAN_IDENTITY_FILE }),
+  };
+
+  const result = configSchema.parse(merged);
+  return result as AgentConfig;
+}

package/src/services/autoUpdater.ts

@@ -0,0 +1,155 @@
+import { platform } from 'os';
+import type { Logger } from '../lib/logger.js';
+import type { WsClient } from './websocket.js';
+import type { Updater } from './updater.js';
+import type { Identity } from '../lib/types.js';
+
+/**
+ * AutoUpdater — periodically polls the server to check if a newer agent version
+ * is available. If found, downloads, verifies, installs, and restarts.
+ *
+ * Check interval: 5 minutes (default).
+ * Uses device API key auth so it works without JWT.
+ */
+
+const DEFAULT_CHECK_INTERVAL_MS = 5 * 60 * 1000; // 5 minutes
+
+export class AutoUpdater {
+  private readonly logger: Logger;
+  private readonly updater: Updater;
+  private readonly wsClient: WsClient;
+  private readonly serverUrl: string;
+  private readonly identity: Identity;
+  private readonly currentVersion: string;
+  private readonly checkIntervalMs: number;
+  private timer: ReturnType<typeof setInterval> | null = null;
+  private checking = false;
+
+  constructor(opts: {
+    logger: Logger;
+    updater: Updater;
+    wsClient: WsClient;
+    serverUrl: string;
+    identity: Identity;
+    currentVersion: string;
+    checkIntervalMs?: number;
+  }) {
+    this.logger = opts.logger;
+    this.updater = opts.updater;
+    this.wsClient = opts.wsClient;
+    this.serverUrl = opts.serverUrl;
+    this.identity = opts.identity;
+    this.currentVersion = opts.currentVersion;
+    this.checkIntervalMs = opts.checkIntervalMs || DEFAULT_CHECK_INTERVAL_MS;
+  }
+
+  start(): void {
+    this.logger.info(`[AutoUpdate] Started — checking every ${Math.round(this.checkIntervalMs / 1000)}s (current: v${this.currentVersion})`);
+
+    // Initial check after 30s (let everything else boot first)
+    setTimeout(() => this.check(), 30_000);
+
+    this.timer = setInterval(() => this.check(), this.checkIntervalMs);
+  }
+
+  stop(): void {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+
+  private async check(): Promise<void> {
+    if (this.checking || this.updater.isBusy()) return;
+    this.checking = true;
+
+    try {
+      const plat = platform() === 'win32' ? 'windows' : 'linux';
+      const url = `${this.serverUrl}/api/agent/check-update?current_version=${encodeURIComponent(this.currentVersion)}&platform=${plat}`;
+
+      const res = await fetch(url, {
+        headers: { 'Authorization': `Bearer ${this.identity.apiKey}` },
+      });
+
+      if (!res.ok) {
+        this.logger.debug(`[AutoUpdate] Check failed: HTTP ${res.status}`);
+        return;
+      }
+
+      const json = await res.json() as { success: boolean; data: {
+        update_available: boolean;
+        version?: string;
+        checksum?: string;
+        download_url?: string;
+      }};
+
+      if (!json.success || !json.data.update_available) {
+        this.logger.debug('[AutoUpdate] No update available');
+        return;
+      }
+
+      const { version, checksum, download_url } = json.data;
+      if (!version || !checksum || !download_url) {
+        this.logger.warn('[AutoUpdate] Server returned incomplete update info');
+        return;
+      }
+
+      this.logger.info(`[AutoUpdate] New version available: v${version} (current: v${this.currentVersion})`);
+
+      // Notify server
+      this.wsClient.send({
+        type: 'agent:update_status',
+        payload: { phase: 'downloading', version },
+        timestamp: Date.now(),
+      });
+
+      // Build full download URL
+      const fullUrl = download_url.startsWith('http')
+        ? download_url
+        : `${this.serverUrl}${download_url}`;
+
+      // Download
+      const filePath = await this.updater.download(fullUrl);
+
+      // Verify
+      this.wsClient.send({
+        type: 'agent:update_status',
+        payload: { phase: 'verifying', version },
+        timestamp: Date.now(),
+      });
+      const valid = await this.updater.verify(filePath, checksum);
+      if (!valid) {
+        this.wsClient.send({
+          type: 'agent:update_status',
+          payload: { phase: 'error', version, error: 'Checksum mismatch' },
+          timestamp: Date.now(),
+        });
+        this.logger.error('[AutoUpdate] Checksum mismatch — aborting');
+        return;
+      }
+
+      // Install
+      this.wsClient.send({
+        type: 'agent:update_status',
+        payload: { phase: 'installing', version },
+        timestamp: Date.now(),
+      });
+      await this.updater.install(filePath, version);
+      this.updater.cleanDownloads();
+
+      // Restart
+      this.wsClient.send({
+        type: 'agent:update_status',
+        payload: { phase: 'restarting', version },
+        timestamp: Date.now(),
+      });
+      this.logger.info(`[AutoUpdate] v${version} installed. Restarting in 2s...`);
+      setTimeout(() => process.exit(0), 2000);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      this.logger.error(`[AutoUpdate] Error: ${msg}`);
+    } finally {
+      this.checking = false;
+    }
+  }
+}