lightman-agent 1.0.5 → 1.0.6

package/src/commands/network.ts

@@ -1,129 +1,129 @@
-import net from 'net';
-import dns from 'dns';
-import { URL } from 'url';
-import si from 'systeminformation';
-import type { CommandHandler } from '../lib/types.js';
-import type { Logger } from '../lib/logger.js';
-
-export function registerNetworkCommands(
-  register: (command: string, handler: CommandHandler) => void,
-  logger: Logger,
-  serverUrl: string
-): void {
-  // network:ping — TCP connect to CMS server, measure round-trip
-  register('network:ping', async () => {
-    const url = new URL(serverUrl);
-    const host = url.hostname;
-    const port = parseInt(url.port, 10) || 3001;
-
-    const start = Date.now();
-    const reachable = await tcpPing(host, port, 5000);
-    const latencyMs = Date.now() - start;
-
-    logger.info(`Network ping: ${host}:${port} → ${reachable ? 'OK' : 'FAIL'} (${latencyMs}ms)`);
-    return { latency_ms: latencyMs, reachable, host, port };
-  });
-
-  // network:bandwidth — Download 1MB test file, measure speed
-  register('network:bandwidth', async () => {
-    const url = `${serverUrl}/api/agent/bandwidth-test`;
-    logger.info(`Bandwidth test: downloading from ${url}`);
-
-    const start = Date.now();
-    try {
-      const response = await fetch(url);
-      if (!response.ok) {
-        throw new Error(`HTTP ${response.status}`);
-      }
-      const buffer = await response.arrayBuffer();
-      const durationMs = Date.now() - start;
-      const sizeMb = buffer.byteLength / (1024 * 1024);
-      const speedMbps = (sizeMb * 8) / (durationMs / 1000);
-
-      logger.info(`Bandwidth: ${speedMbps.toFixed(2)} Mbps (${buffer.byteLength} bytes in ${durationMs}ms)`);
-      return {
-        speed_mbps: Math.round(speedMbps * 100) / 100,
-        duration_ms: durationMs,
-        bytes: buffer.byteLength,
-      };
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      logger.error('Bandwidth test failed:', message);
-      throw new Error(`Bandwidth test failed: ${message}`);
-    }
-  });
-
-  // network:dns — Resolve CMS hostname
-  register('network:dns', async () => {
-    const url = new URL(serverUrl);
-    const hostname = url.hostname;
-
-    logger.info(`DNS resolve: ${hostname}`);
-    const start = Date.now();
-
-    try {
-      const addresses = await new Promise<string[]>((resolve, reject) => {
-        dns.resolve(hostname, (err, addrs) => {
-          if (err) reject(err);
-          else resolve(addrs);
-        });
-      });
-      const timeMs = Date.now() - start;
-
-      logger.info(`DNS resolved: ${hostname} → ${addresses.join(', ')} (${timeMs}ms)`);
-      return { resolved: true, addresses, time_ms: timeMs, hostname };
-    } catch (err) {
-      const timeMs = Date.now() - start;
-      // If it's an IP address, DNS resolve will fail — that's OK
-      if (net.isIP(hostname)) {
-        return { resolved: true, addresses: [hostname], time_ms: timeMs, hostname, note: 'IP address (no DNS needed)' };
-      }
-      const message = err instanceof Error ? err.message : String(err);
-      logger.error('DNS resolve failed:', message);
-      return { resolved: false, addresses: [], time_ms: timeMs, hostname, error: message };
-    }
-  });
-
-  // network:interfaces — List network interfaces
-  register('network:interfaces', async () => {
-    const ifaces = await si.networkInterfaces();
-    const ifaceList = Array.isArray(ifaces) ? ifaces : [ifaces];
-
-    const interfaces = ifaceList
-      .filter((iface) => !iface.internal && iface.ip4)
-      .map((iface) => ({
-        name: iface.iface,
-        ip4: iface.ip4,
-        mac: iface.mac,
-        speed: iface.speed,
-        type: iface.type,
-      }));
-
-    logger.info(`Network interfaces: ${interfaces.length} found`);
-    return { interfaces };
-  });
-}
-
-/**
- * TCP ping: attempt a TCP connection and measure latency.
- * Returns true if connection succeeds within timeout.
- */
-function tcpPing(host: string, port: number, timeoutMs: number): Promise<boolean> {
-  return new Promise((resolve) => {
-    const socket = new net.Socket();
-    let resolved = false;
-
-    const done = (result: boolean) => {
-      if (resolved) return;
-      resolved = true;
-      socket.destroy();
-      resolve(result);
-    };
-
-    socket.setTimeout(timeoutMs);
-    socket.on('connect', () => done(true));
-    socket.on('timeout', () => done(false));
-    socket.on('error', () => done(false));
-    socket.connect(port, host);
-  });
-}
+import net from 'net';
+import dns from 'dns';
+import { URL } from 'url';
+import si from 'systeminformation';
+import type { CommandHandler } from '../lib/types.js';
+import type { Logger } from '../lib/logger.js';
+
+export function registerNetworkCommands(
+  register: (command: string, handler: CommandHandler) => void,
+  logger: Logger,
+  serverUrl: string
+): void {
+  // network:ping — TCP connect to CMS server, measure round-trip
+  register('network:ping', async () => {
+    const url = new URL(serverUrl);
+    const host = url.hostname;
+    const port = parseInt(url.port, 10) || 3001;
+
+    const start = Date.now();
+    const reachable = await tcpPing(host, port, 5000);
+    const latencyMs = Date.now() - start;
+
+    logger.info(`Network ping: ${host}:${port} → ${reachable ? 'OK' : 'FAIL'} (${latencyMs}ms)`);
+    return { latency_ms: latencyMs, reachable, host, port };
+  });
+
+  // network:bandwidth — Download 1MB test file, measure speed
+  register('network:bandwidth', async () => {
+    const url = `${serverUrl}/api/agent/bandwidth-test`;
+    logger.info(`Bandwidth test: downloading from ${url}`);
+
+    const start = Date.now();
+    try {
+      const response = await fetch(url);
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}`);
+      }
+      const buffer = await response.arrayBuffer();
+      const durationMs = Date.now() - start;
+      const sizeMb = buffer.byteLength / (1024 * 1024);
+      const speedMbps = (sizeMb * 8) / (durationMs / 1000);
+
+      logger.info(`Bandwidth: ${speedMbps.toFixed(2)} Mbps (${buffer.byteLength} bytes in ${durationMs}ms)`);
+      return {
+        speed_mbps: Math.round(speedMbps * 100) / 100,
+        duration_ms: durationMs,
+        bytes: buffer.byteLength,
+      };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      logger.error('Bandwidth test failed:', message);
+      throw new Error(`Bandwidth test failed: ${message}`);
+    }
+  });
+
+  // network:dns — Resolve CMS hostname
+  register('network:dns', async () => {
+    const url = new URL(serverUrl);
+    const hostname = url.hostname;
+
+    logger.info(`DNS resolve: ${hostname}`);
+    const start = Date.now();
+
+    try {
+      const addresses = await new Promise<string[]>((resolve, reject) => {
+        dns.resolve(hostname, (err, addrs) => {
+          if (err) reject(err);
+          else resolve(addrs);
+        });
+      });
+      const timeMs = Date.now() - start;
+
+      logger.info(`DNS resolved: ${hostname} → ${addresses.join(', ')} (${timeMs}ms)`);
+      return { resolved: true, addresses, time_ms: timeMs, hostname };
+    } catch (err) {
+      const timeMs = Date.now() - start;
+      // If it's an IP address, DNS resolve will fail — that's OK
+      if (net.isIP(hostname)) {
+        return { resolved: true, addresses: [hostname], time_ms: timeMs, hostname, note: 'IP address (no DNS needed)' };
+      }
+      const message = err instanceof Error ? err.message : String(err);
+      logger.error('DNS resolve failed:', message);
+      return { resolved: false, addresses: [], time_ms: timeMs, hostname, error: message };
+    }
+  });
+
+  // network:interfaces — List network interfaces
+  register('network:interfaces', async () => {
+    const ifaces = await si.networkInterfaces();
+    const ifaceList = Array.isArray(ifaces) ? ifaces : [ifaces];
+
+    const interfaces = ifaceList
+      .filter((iface) => !iface.internal && iface.ip4)
+      .map((iface) => ({
+        name: iface.iface,
+        ip4: iface.ip4,
+        mac: iface.mac,
+        speed: iface.speed,
+        type: iface.type,
+      }));
+
+    logger.info(`Network interfaces: ${interfaces.length} found`);
+    return { interfaces };
+  });
+}
+
+/**
+ * TCP ping: attempt a TCP connection and measure latency.
+ * Returns true if connection succeeds within timeout.
+ */
+function tcpPing(host: string, port: number, timeoutMs: number): Promise<boolean> {
+  return new Promise((resolve) => {
+    const socket = new net.Socket();
+    let resolved = false;
+
+    const done = (result: boolean) => {
+      if (resolved) return;
+      resolved = true;
+      socket.destroy();
+      resolve(result);
+    };
+
+    socket.setTimeout(timeoutMs);
+    socket.on('connect', () => done(true));
+    socket.on('timeout', () => done(false));
+    socket.on('error', () => done(false));
+    socket.connect(port, host);
+  });
+}

package/src/commands/power.ts

@@ -1,163 +1,163 @@
-import { execFile } from 'child_process';
-import { z } from 'zod';
-import type { CommandHandler } from '../lib/types.js';
-import { getPlatform } from '../lib/platform.js';
-import type { Logger } from '../lib/logger.js';
-
-// --- Zod Schemas ---
-const ShutdownDelayedArgsSchema = z.object({
-  delayMs: z.number().finite().optional(),
-});
-
-let pendingShutdown: ReturnType<typeof setTimeout> | null = null;
-
-interface ExecCommand {
-  readonly bin: string;
-  readonly args: readonly string[];
-}
-
-function execCommand(cmd: ExecCommand, logger: Logger): void {
-  execFile(cmd.bin, [...cmd.args], (err, stdout, stderr) => {
-    if (err) {
-      logger.error(`Exec failed: ${cmd.bin}`, err.message);
-    }
-    if (stderr) {
-      logger.warn(`Exec stderr: ${cmd.bin}`, stderr);
-    }
-    if (stdout) {
-      logger.debug(`Exec stdout: ${cmd.bin}`, stdout);
-    }
-  });
-}
-
-function getShutdownCommand(): ExecCommand {
-  const platform = getPlatform();
-  switch (platform) {
-    case 'windows':
-      return { bin: 'shutdown', args: ['/s', '/t', '0'] };
-    case 'darwin':
-    case 'linux':
-    default:
-      return { bin: 'shutdown', args: ['-h', 'now'] };
-  }
-}
-
-function getRebootCommand(): ExecCommand {
-  const platform = getPlatform();
-  switch (platform) {
-    case 'windows':
-      return { bin: 'shutdown', args: ['/r', '/t', '0'] };
-    case 'darwin':
-    case 'linux':
-    default:
-      return { bin: 'shutdown', args: ['-r', 'now'] };
-  }
-}
-
-function getSuspendCommand(): ExecCommand {
-  const platform = getPlatform();
-  switch (platform) {
-    case 'linux':
-      return { bin: 'systemctl', args: ['suspend'] };
-    case 'windows':
-      return { bin: 'rundll32.exe', args: ['powrprof.dll,SetSuspendState', '0,1,0'] };
-    case 'darwin':
-      return { bin: 'pmset', args: ['sleepnow'] };
-    default:
-      return { bin: 'systemctl', args: ['suspend'] };
-  }
-}
-
-export function registerPowerCommands(
-  register: (command: string, handler: CommandHandler) => void,
-  logger: Logger
-): void {
-  // system:shutdown — graceful shutdown with 5s delay
-  register('system:shutdown', async () => {
-    const cmd = getShutdownCommand();
-    logger.info(`Scheduling shutdown in 5000ms: ${cmd}`);
-
-    setTimeout(() => {
-      try {
-        execCommand(cmd, logger);
-      } catch (err) {
-        logger.error('Shutdown exec error', err instanceof Error ? err.message : String(err));
-      }
-    }, 5000);
-
-    return { delayed: true, delayMs: 5000 };
-  });
-
-  // system:reboot — graceful reboot with 5s delay
-  register('system:reboot', async () => {
-    const cmd = getRebootCommand();
-    logger.info(`Scheduling reboot in 5000ms: ${cmd}`);
-
-    setTimeout(() => {
-      try {
-        execCommand(cmd, logger);
-      } catch (err) {
-        logger.error('Reboot exec error', err instanceof Error ? err.message : String(err));
-      }
-    }, 5000);
-
-    return { delayed: true, delayMs: 5000 };
-  });
-
-  // system:suspend — immediate suspend
-  register('system:suspend', async () => {
-    const cmd = getSuspendCommand();
-    logger.info(`Executing suspend: ${cmd}`);
-
-    try {
-      execCommand(cmd, logger);
-    } catch (err) {
-      logger.error('Suspend exec error', err instanceof Error ? err.message : String(err));
-    }
-
-    return { suspended: true };
-  });
-
-  // system:shutdown-delayed — shutdown after configurable delay (5s to 24h)
-  register('system:shutdown-delayed', async (args) => {
-    const parsed = ShutdownDelayedArgsSchema.safeParse(args ?? {});
-    if (!parsed.success) {
-      throw new Error(`Invalid args: ${parsed.error.issues.map((i) => i.message).join(', ')}`);
-    }
-    const rawDelay = parsed.data.delayMs ?? 60000;
-    const delayMs = Math.max(5000, Math.min(rawDelay, 86_400_000));
-    const cmd = getShutdownCommand();
-
-    logger.info(`Scheduling delayed shutdown in ${delayMs}ms: ${cmd}`);
-
-    // Clear any existing pending shutdown
-    if (pendingShutdown !== null) {
-      clearTimeout(pendingShutdown);
-      logger.info('Cleared previous pending shutdown');
-    }
-
-    pendingShutdown = setTimeout(() => {
-      try {
-        execCommand(cmd, logger);
-      } catch (err) {
-        logger.error('Delayed shutdown exec error', err instanceof Error ? err.message : String(err));
-      }
-      pendingShutdown = null;
-    }, delayMs);
-
-    return { delayed: true, delayMs };
-  });
-
-  // system:cancel-shutdown — cancel a pending delayed shutdown
-  register('system:cancel-shutdown', async () => {
-    if (pendingShutdown !== null) {
-      clearTimeout(pendingShutdown);
-      pendingShutdown = null;
-      logger.info('Pending shutdown cancelled');
-      return { cancelled: true };
-    }
-
-    logger.info('No pending shutdown to cancel');
-    return { cancelled: false, reason: 'no pending shutdown' };
-  });
-}
+import { execFile } from 'child_process';
+import { z } from 'zod';
+import type { CommandHandler } from '../lib/types.js';
+import { getPlatform } from '../lib/platform.js';
+import type { Logger } from '../lib/logger.js';
+
+// --- Zod Schemas ---
+const ShutdownDelayedArgsSchema = z.object({
+  delayMs: z.number().finite().optional(),
+});
+
+let pendingShutdown: ReturnType<typeof setTimeout> | null = null;
+
+interface ExecCommand {
+  readonly bin: string;
+  readonly args: readonly string[];
+}
+
+function execCommand(cmd: ExecCommand, logger: Logger): void {
+  execFile(cmd.bin, [...cmd.args], (err, stdout, stderr) => {
+    if (err) {
+      logger.error(`Exec failed: ${cmd.bin}`, err.message);
+    }
+    if (stderr) {
+      logger.warn(`Exec stderr: ${cmd.bin}`, stderr);
+    }
+    if (stdout) {
+      logger.debug(`Exec stdout: ${cmd.bin}`, stdout);
+    }
+  });
+}
+
+function getShutdownCommand(): ExecCommand {
+  const platform = getPlatform();
+  switch (platform) {
+    case 'windows':
+      return { bin: 'shutdown', args: ['/s', '/t', '0'] };
+    case 'darwin':
+    case 'linux':
+    default:
+      return { bin: 'shutdown', args: ['-h', 'now'] };
+  }
+}
+
+function getRebootCommand(): ExecCommand {
+  const platform = getPlatform();
+  switch (platform) {
+    case 'windows':
+      return { bin: 'shutdown', args: ['/r', '/t', '0'] };
+    case 'darwin':
+    case 'linux':
+    default:
+      return { bin: 'shutdown', args: ['-r', 'now'] };
+  }
+}
+
+function getSuspendCommand(): ExecCommand {
+  const platform = getPlatform();
+  switch (platform) {
+    case 'linux':
+      return { bin: 'systemctl', args: ['suspend'] };
+    case 'windows':
+      return { bin: 'rundll32.exe', args: ['powrprof.dll,SetSuspendState', '0,1,0'] };
+    case 'darwin':
+      return { bin: 'pmset', args: ['sleepnow'] };
+    default:
+      return { bin: 'systemctl', args: ['suspend'] };
+  }
+}
+
+export function registerPowerCommands(
+  register: (command: string, handler: CommandHandler) => void,
+  logger: Logger
+): void {
+  // system:shutdown — graceful shutdown with 5s delay
+  register('system:shutdown', async () => {
+    const cmd = getShutdownCommand();
+    logger.info(`Scheduling shutdown in 5000ms: ${cmd}`);
+
+    setTimeout(() => {
+      try {
+        execCommand(cmd, logger);
+      } catch (err) {
+        logger.error('Shutdown exec error', err instanceof Error ? err.message : String(err));
+      }
+    }, 5000);
+
+    return { delayed: true, delayMs: 5000 };
+  });
+
+  // system:reboot — graceful reboot with 5s delay
+  register('system:reboot', async () => {
+    const cmd = getRebootCommand();
+    logger.info(`Scheduling reboot in 5000ms: ${cmd}`);
+
+    setTimeout(() => {
+      try {
+        execCommand(cmd, logger);
+      } catch (err) {
+        logger.error('Reboot exec error', err instanceof Error ? err.message : String(err));
+      }
+    }, 5000);
+
+    return { delayed: true, delayMs: 5000 };
+  });
+
+  // system:suspend — immediate suspend
+  register('system:suspend', async () => {
+    const cmd = getSuspendCommand();
+    logger.info(`Executing suspend: ${cmd}`);
+
+    try {
+      execCommand(cmd, logger);
+    } catch (err) {
+      logger.error('Suspend exec error', err instanceof Error ? err.message : String(err));
+    }
+
+    return { suspended: true };
+  });
+
+  // system:shutdown-delayed — shutdown after configurable delay (5s to 24h)
+  register('system:shutdown-delayed', async (args) => {
+    const parsed = ShutdownDelayedArgsSchema.safeParse(args ?? {});
+    if (!parsed.success) {
+      throw new Error(`Invalid args: ${parsed.error.issues.map((i) => i.message).join(', ')}`);
+    }
+    const rawDelay = parsed.data.delayMs ?? 60000;
+    const delayMs = Math.max(5000, Math.min(rawDelay, 86_400_000));
+    const cmd = getShutdownCommand();
+
+    logger.info(`Scheduling delayed shutdown in ${delayMs}ms: ${cmd}`);
+
+    // Clear any existing pending shutdown
+    if (pendingShutdown !== null) {
+      clearTimeout(pendingShutdown);
+      logger.info('Cleared previous pending shutdown');
+    }
+
+    pendingShutdown = setTimeout(() => {
+      try {
+        execCommand(cmd, logger);
+      } catch (err) {
+        logger.error('Delayed shutdown exec error', err instanceof Error ? err.message : String(err));
+      }
+      pendingShutdown = null;
+    }, delayMs);
+
+    return { delayed: true, delayMs };
+  });
+
+  // system:cancel-shutdown — cancel a pending delayed shutdown
+  register('system:cancel-shutdown', async () => {
+    if (pendingShutdown !== null) {
+      clearTimeout(pendingShutdown);
+      pendingShutdown = null;
+      logger.info('Pending shutdown cancelled');
+      return { cancelled: true };
+    }
+
+    logger.info('No pending shutdown to cancel');
+    return { cancelled: false, reason: 'no pending shutdown' };
+  });
+}