itwillsync 1.6.2 → 1.7.0

package/dist/hub/daemon.js

@@ -3649,11 +3649,11 @@ var require_websocket_server = __commonJS({
 });
 
 // src/daemon.ts
-import { writeFileSync as writeFileSync3, mkdirSync as mkdirSync3, unlinkSync, existsSync as existsSync3, readdirSync, statSync } from "fs";
-import { homedir as homedir4 } from "os";
-import { join as join4, dirname as dirname3 } from "path";
+import { writeFileSync as writeFileSync4, mkdirSync as mkdirSync3, unlinkSync as unlinkSync2, existsSync as existsSync4, readdirSync, statSync } from "fs";
+import { homedir as homedir5 } from "os";
+import { join as join5, dirname as dirname3 } from "path";
 import { fileURLToPath } from "url";
-import { spawn } from "child_process";
+import { spawn as spawn2 } from "child_process";
 
 // src/auth.ts
 import { randomBytes, timingSafeEqual } from "crypto";
@@ -4127,8 +4127,8 @@ function createInternalApi(options) {
         }
         let memoryKB = 0;
         try {
-          const { execFileSync } = await import("child_process");
-          const output = execFileSync("ps", ["-o", "rss=", "-p", String(session.pid)], {
+          const { execFileSync: execFileSync2 } = await import("child_process");
+          const output = execFileSync2("ps", ["-o", "rss=", "-p", String(session.pid)], {
             encoding: "utf-8",
             timeout: 2e3
           });
@@ -4201,7 +4201,7 @@ var MIME_TYPES = {
 var COMPRESSIBLE = /* @__PURE__ */ new Set([".html", ".js", ".css", ".json", ".svg"]);
 var PING_INTERVAL_MS = 3e4;
 function createDashboardServer(options) {
-  const { registry, masterToken, dashboardPath, host, port, previewCollector, toolHistory, onCreateSession } = options;
+  const { registry, masterToken, dashboardPath, host, port, previewCollector, toolHistory, sleepPrevention, onCreateSession } = options;
   const homeDir = homedir3();
   const clients = /* @__PURE__ */ new Set();
   const aliveMap = /* @__PURE__ */ new WeakMap();
@@ -4358,6 +4358,9 @@ function createDashboardServer(options) {
     aliveMap.set(ws, true);
     const sessions = registry.getAll();
     ws.send(JSON.stringify({ type: "sessions", sessions }));
+    if (sleepPrevention) {
+      ws.send(JSON.stringify({ type: "sleep-state", state: sleepPrevention.getState() }));
+    }
     if (previewCollector) {
       const previews = previewCollector.getAllPreviews();
       for (const [sessionId, lines] of previews) {
@@ -4423,6 +4426,30 @@ function createDashboardServer(options) {
             }
             break;
           }
+          case "enable-sleep-prevention": {
+            if (!sleepPrevention) {
+              ws.send(JSON.stringify({ type: "sleep-error", error: "Sleep prevention not available" }));
+              break;
+            }
+            const password = typeof msg.password === "string" ? msg.password : "";
+            if (!password) {
+              ws.send(JSON.stringify({ type: "sleep-error", error: "Password is required" }));
+              break;
+            }
+            const enableResult = await sleepPrevention.enable(password);
+            if (enableResult.success) {
+              broadcast({ type: "sleep-state", state: sleepPrevention.getState() });
+            } else {
+              ws.send(JSON.stringify({ type: "sleep-error", error: enableResult.error }));
+            }
+            break;
+          }
+          case "disable-sleep-prevention": {
+            if (!sleepPrevention) break;
+            await sleepPrevention.disable(true);
+            broadcast({ type: "sleep-state", state: sleepPrevention.getState() });
+            break;
+          }
           case "get-metadata": {
             const session = registry.getById(msg.sessionId);
             if (!session) {
@@ -4431,8 +4458,8 @@ function createDashboardServer(options) {
             }
             let memoryKB = 0;
             try {
-              const { execFileSync } = await import("child_process");
-              const output = execFileSync("ps", ["-o", "rss=", "-p", String(session.pid)], {
+              const { execFileSync: execFileSync2 } = await import("child_process");
+              const output = execFileSync2("ps", ["-o", "rss=", "-p", String(session.pid)], {
                 encoding: "utf-8",
                 timeout: 2e3
               });
@@ -4687,24 +4714,360 @@ var PreviewCollector = class extends EventEmitter2 {
   }
 };
 
+// src/sleep-prevention.ts
+import { spawn, execFileSync } from "child_process";
+import { writeFileSync as writeFileSync3, readFileSync as readFileSync3, unlinkSync, existsSync as existsSync3 } from "fs";
+import { join as join4 } from "path";
+import { homedir as homedir4 } from "os";
+var SUPPORTED_PLATFORMS = /* @__PURE__ */ new Set(["darwin", "win32", "linux"]);
+var COMMAND_TIMEOUT_MS = 1e4;
+var SYNC_TIMEOUT_MS = 5e3;
+function getHubDir() {
+  return process.env.ITWILLSYNC_CONFIG_DIR || join4(homedir4(), ".itwillsync");
+}
+var SleepPrevention = class {
+  enabled = false;
+  enabledAt = null;
+  error = null;
+  busy = false;
+  flagFilePath;
+  platform;
+  constructor() {
+    this.platform = process.platform;
+    this.flagFilePath = join4(getHubDir(), "sleep-prevention.json");
+    this.checkOrphanedFlag();
+  }
+  getState() {
+    return {
+      enabled: this.enabled,
+      platform: this.platform,
+      enabledAt: this.enabledAt,
+      error: this.error,
+      supported: SUPPORTED_PLATFORMS.has(this.platform)
+    };
+  }
+  async enable(password) {
+    if (this.busy) {
+      return { success: false, error: "Operation in progress" };
+    }
+    if (!SUPPORTED_PLATFORMS.has(this.platform)) {
+      return { success: false, error: `Sleep prevention is not supported on ${this.platform}` };
+    }
+    if (this.enabled) {
+      return { success: true };
+    }
+    this.busy = true;
+    try {
+      let result;
+      switch (this.platform) {
+        case "darwin":
+          result = await this.runSudo(["pmset", "-a", "disablesleep", "1"], password);
+          break;
+        case "win32":
+          result = await this.enableWindows();
+          break;
+        case "linux":
+          result = await this.enableLinux(password);
+          break;
+        default:
+          result = { success: false, error: "Unsupported platform" };
+      }
+      if (result.success) {
+        this.enabled = true;
+        this.enabledAt = Date.now();
+        this.error = null;
+        this.writeFlagFile();
+      } else {
+        this.error = result.error || "Unknown error";
+      }
+      return result;
+    } finally {
+      this.busy = false;
+    }
+  }
+  /**
+   * Disable sleep prevention. When `force` is true (user-initiated), the flag
+   * file is always deleted. When false (orphan revert), the flag file persists
+   * if the system command fails so the next restart can retry.
+   */
+  async disable(force = false) {
+    if (this.busy) {
+      return { success: false, error: "Operation in progress" };
+    }
+    if (!this.enabled) {
+      return { success: true };
+    }
+    this.busy = true;
+    try {
+      let reverted = false;
+      switch (this.platform) {
+        case "darwin":
+          reverted = (await this.runCommand("sudo", ["-n", "pmset", "-a", "disablesleep", "0"])).exitCode === 0;
+          break;
+        case "win32":
+          await this.disableWindows();
+          reverted = true;
+          break;
+        case "linux":
+          reverted = await this.disableLinux();
+          break;
+      }
+      this.enabled = false;
+      this.enabledAt = null;
+      this.error = null;
+      if (reverted || force) {
+        this.deleteFlagFile();
+      }
+      return { success: true };
+    } finally {
+      this.busy = false;
+    }
+  }
+  /** Synchronous cleanup for SIGTERM/SIGINT handlers. Best-effort. */
+  cleanupSync() {
+    if (!this.enabled) return;
+    try {
+      switch (this.platform) {
+        case "darwin":
+          execFileSync("sudo", ["-n", "pmset", "-a", "disablesleep", "0"], {
+            timeout: SYNC_TIMEOUT_MS,
+            stdio: "ignore"
+          });
+          break;
+        case "win32":
+          execFileSync("powercfg", ["/setacvalueindex", "SCHEME_CURRENT", "SUB_BUTTONS", "LIDACTION", "1"], { timeout: SYNC_TIMEOUT_MS, stdio: "ignore" });
+          execFileSync("powercfg", ["/setdcvalueindex", "SCHEME_CURRENT", "SUB_BUTTONS", "LIDACTION", "1"], { timeout: SYNC_TIMEOUT_MS, stdio: "ignore" });
+          execFileSync("powercfg", ["/s", "SCHEME_CURRENT"], { timeout: SYNC_TIMEOUT_MS, stdio: "ignore" });
+          break;
+        case "linux":
+          this.revertLogindConfSync();
+          execFileSync("sudo", ["-n", "systemctl", "restart", "systemd-logind"], {
+            timeout: SYNC_TIMEOUT_MS,
+            stdio: "ignore"
+          });
+          break;
+      }
+    } catch {
+    }
+    this.enabled = false;
+    this.enabledAt = null;
+    this.deleteFlagFile();
+  }
+  // --- Windows ---
+  async enableWindows() {
+    const commands = [
+      ["powercfg", ["/setacvalueindex", "SCHEME_CURRENT", "SUB_BUTTONS", "LIDACTION", "0"]],
+      ["powercfg", ["/setdcvalueindex", "SCHEME_CURRENT", "SUB_BUTTONS", "LIDACTION", "0"]],
+      ["powercfg", ["/s", "SCHEME_CURRENT"]]
+    ];
+    for (const [cmd, args] of commands) {
+      const result = await this.runCommand(cmd, args);
+      if (result.exitCode !== 0) {
+        return { success: false, error: `powercfg failed: ${result.stderr || "requires admin privileges"}` };
+      }
+    }
+    return { success: true };
+  }
+  async disableWindows() {
+    await this.runCommand("powercfg", ["/setacvalueindex", "SCHEME_CURRENT", "SUB_BUTTONS", "LIDACTION", "1"]);
+    await this.runCommand("powercfg", ["/setdcvalueindex", "SCHEME_CURRENT", "SUB_BUTTONS", "LIDACTION", "1"]);
+    await this.runCommand("powercfg", ["/s", "SCHEME_CURRENT"]);
+  }
+  // --- Linux ---
+  async enableLinux(password) {
+    const confPath = "/etc/systemd/logind.conf";
+    const backupPath = join4(getHubDir(), "logind.conf.backup");
+    try {
+      const readResult = await this.runSudo(["cat", confPath], password, { captureStdout: true });
+      if (!readResult.success) {
+        return { success: false, error: readResult.error || "Failed to read logind.conf" };
+      }
+      const original = readResult.stdout;
+      writeFileSync3(backupPath, original, "utf-8");
+      let modified = original;
+      const settings = {
+        HandleLidSwitch: "ignore",
+        HandleLidSwitchExternalPower: "ignore",
+        HandleLidSwitchDocked: "ignore"
+      };
+      for (const [key, value] of Object.entries(settings)) {
+        const regex = new RegExp(`^#?\\s*${key}\\s*=.*$`, "m");
+        if (regex.test(modified)) {
+          modified = modified.replace(regex, `${key}=${value}`);
+        } else {
+          modified = modified.replace(/^\[Login\]/m, `[Login]
+${key}=${value}`);
+        }
+      }
+      const writeResult = await this.runSudo(["tee", confPath], password, { stdin: modified });
+      if (!writeResult.success) {
+        return { success: false, error: "Failed to write logind.conf" };
+      }
+      const restartResult = await this.runSudo(["systemctl", "restart", "systemd-logind"], password);
+      if (!restartResult.success) {
+        try {
+          const backup = readFileSync3(backupPath, "utf-8");
+          await this.runSudo(["tee", confPath], password, { stdin: backup });
+          await this.runSudo(["systemctl", "restart", "systemd-logind"], password);
+        } catch {
+        }
+        return { success: false, error: "Failed to restart systemd-logind" };
+      }
+      return { success: true };
+    } catch (err) {
+      return { success: false, error: err.message };
+    }
+  }
+  async disableLinux() {
+    const backupPath = join4(getHubDir(), "logind.conf.backup");
+    if (!existsSync3(backupPath)) return true;
+    try {
+      const backup = readFileSync3(backupPath, "utf-8");
+      const teeResult = await this.runCommand("sudo", ["-n", "tee", "/etc/systemd/logind.conf"], { stdin: backup });
+      const restartResult = await this.runCommand("sudo", ["-n", "systemctl", "restart", "systemd-logind"]);
+      const ok = teeResult.exitCode === 0 && restartResult.exitCode === 0;
+      if (ok) unlinkSync(backupPath);
+      return ok;
+    } catch {
+      return false;
+    }
+  }
+  revertLogindConfSync() {
+    const backupPath = join4(getHubDir(), "logind.conf.backup");
+    if (!existsSync3(backupPath)) return;
+    try {
+      const backup = readFileSync3(backupPath, "utf-8");
+      execFileSync("sudo", ["-n", "tee", "/etc/systemd/logind.conf"], {
+        input: backup,
+        timeout: SYNC_TIMEOUT_MS,
+        stdio: ["pipe", "ignore", "ignore"]
+      });
+      unlinkSync(backupPath);
+    } catch {
+    }
+  }
+  // --- Helpers ---
+  /** Run a command via sudo -S (password on stdin). Optionally pipe extra stdin or capture stdout. */
+  runSudo(args, password, opts) {
+    return new Promise((resolve) => {
+      const capture = opts?.captureStdout ?? false;
+      const proc = spawn("sudo", ["-S", ...args], {
+        stdio: ["pipe", capture ? "pipe" : "ignore", "pipe"]
+      });
+      let stdout = "";
+      let stderr = "";
+      if (capture) proc.stdout.on("data", (d) => {
+        stdout += d.toString();
+      });
+      proc.stderr.on("data", (d) => {
+        stderr += d.toString();
+      });
+      const timer = setTimeout(() => {
+        proc.kill("SIGKILL");
+        resolve({ success: false, error: "Command timed out" });
+      }, COMMAND_TIMEOUT_MS);
+      proc.on("close", (code) => {
+        clearTimeout(timer);
+        if (code === 0) {
+          resolve({ success: true, ...capture && { stdout } });
+        } else {
+          const msg = stderr.toLowerCase().includes("incorrect password") ? "Incorrect password" : stderr.trim() || `Command failed with exit code ${code}`;
+          resolve({ success: false, error: msg });
+        }
+      });
+      proc.on("error", (err) => {
+        clearTimeout(timer);
+        resolve({ success: false, error: err.message });
+      });
+      proc.stdin.write(password + "\n");
+      if (opts?.stdin) proc.stdin.write(opts.stdin);
+      proc.stdin.end();
+    });
+  }
+  /** Run a command without sudo password. Optionally pipe stdin. */
+  runCommand(cmd, args, opts) {
+    return new Promise((resolve) => {
+      const hasStdin = opts?.stdin != null;
+      const proc = spawn(cmd, args, {
+        stdio: [hasStdin ? "pipe" : "ignore", "ignore", "pipe"]
+      });
+      let stderr = "";
+      proc.stderr.on("data", (d) => {
+        stderr += d.toString();
+      });
+      const timer = setTimeout(() => {
+        proc.kill("SIGKILL");
+        resolve({ exitCode: 1, stderr: "Command timed out" });
+      }, COMMAND_TIMEOUT_MS);
+      proc.on("close", (code) => {
+        clearTimeout(timer);
+        resolve({ exitCode: code ?? 1, stderr });
+      });
+      proc.on("error", (err) => {
+        clearTimeout(timer);
+        resolve({ exitCode: 1, stderr: err.message });
+      });
+      if (hasStdin) {
+        proc.stdin.write(opts.stdin);
+        proc.stdin.end();
+      }
+    });
+  }
+  writeFlagFile() {
+    const data = {
+      enabled: true,
+      platform: this.platform,
+      enabledAt: this.enabledAt || Date.now()
+    };
+    try {
+      writeFileSync3(this.flagFilePath, JSON.stringify(data, null, 2) + "\n", "utf-8");
+    } catch {
+    }
+  }
+  deleteFlagFile() {
+    try {
+      if (existsSync3(this.flagFilePath)) {
+        unlinkSync(this.flagFilePath);
+      }
+    } catch {
+    }
+  }
+  checkOrphanedFlag() {
+    try {
+      if (!existsSync3(this.flagFilePath)) return;
+      const raw = readFileSync3(this.flagFilePath, "utf-8");
+      const data = JSON.parse(raw);
+      if (data.enabled) {
+        console.log("Reverting orphaned sleep prevention setting...");
+        this.enabled = true;
+        this.enabledAt = data.enabledAt;
+        this.disable().catch(() => {
+        });
+      }
+    } catch {
+      this.deleteFlagFile();
+    }
+  }
+};
+
 // src/daemon.ts
 var HUB_EXTERNAL_PORT = 7962;
 var HUB_INTERNAL_PORT = 7963;
 var AUTO_SHUTDOWN_DELAY_MS = 3e4;
-function getHubDir() {
-  return process.env.ITWILLSYNC_CONFIG_DIR || join4(homedir4(), ".itwillsync");
+function getHubDir2() {
+  return process.env.ITWILLSYNC_CONFIG_DIR || join5(homedir5(), ".itwillsync");
 }
 function getPidPath() {
-  return join4(getHubDir(), "hub.pid");
+  return join5(getHubDir2(), "hub.pid");
 }
 function getHubConfigPath() {
-  return join4(getHubDir(), "hub.json");
+  return join5(getHubDir2(), "hub.json");
 }
 function isValidToolName(tool) {
   return /^[a-zA-Z0-9._-]+$/.test(tool) && tool.length > 0 && tool.length <= 100;
 }
 function spawnSession(tool, cwd, cliEntryPath) {
-  const child = spawn(process.execPath, [cliEntryPath, "--headless", "--", tool], {
+  const child = spawn2(process.execPath, [cliEntryPath, "--headless", "--", tool], {
     cwd,
     stdio: "ignore",
     detached: true,
@@ -4714,11 +5077,11 @@ function spawnSession(tool, cwd, cliEntryPath) {
   return child;
 }
 async function main() {
-  const hubDir = getHubDir();
+  const hubDir = getHubDir2();
   mkdirSync3(hubDir, { recursive: true });
   const masterToken = generateToken();
   const startedAt = Date.now();
-  writeFileSync3(getPidPath(), String(process.pid), "utf-8");
+  writeFileSync4(getPidPath(), String(process.pid), "utf-8");
   const hubConfig = {
     masterToken,
     externalPort: HUB_EXTERNAL_PORT,
@@ -4726,21 +5089,22 @@ async function main() {
     pid: process.pid,
     startedAt
   };
-  writeFileSync3(getHubConfigPath(), JSON.stringify(hubConfig, null, 2) + "\n", "utf-8");
+  writeFileSync4(getHubConfigPath(), JSON.stringify(hubConfig, null, 2) + "\n", "utf-8");
   const sessionStore = new SessionStore();
   const registry = new SessionRegistry({ store: sessionStore });
   registry.startHealthChecks();
   const toolHistory = new ToolHistory();
-  const logsDir = join4(hubDir, "logs");
-  if (existsSync3(logsDir)) {
+  const sleepPrevention = new SleepPrevention();
+  const logsDir = join5(hubDir, "logs");
+  if (existsSync4(logsDir)) {
     const retentionMs = 30 * 864e5;
     const cutoff = Date.now() - retentionMs;
     try {
       for (const file of readdirSync(logsDir)) {
-        const filePath = join4(logsDir, file);
+        const filePath = join5(logsDir, file);
         try {
           const stat2 = statSync(filePath);
-          if (stat2.mtimeMs < cutoff) unlinkSync(filePath);
+          if (stat2.mtimeMs < cutoff) unlinkSync2(filePath);
         } catch {
         }
       }
@@ -4748,8 +5112,8 @@ async function main() {
     }
   }
   const __dirname = dirname3(fileURLToPath(import.meta.url));
-  const dashboardPath = join4(__dirname, "dashboard");
-  const cliEntryPath = join4(__dirname, "..", "index.js");
+  const dashboardPath = join5(__dirname, "dashboard");
+  const cliEntryPath = join5(__dirname, "..", "index.js");
   const internalApi = createInternalApi({
     registry,
     port: HUB_INTERNAL_PORT
@@ -4763,6 +5127,7 @@ async function main() {
     port: HUB_EXTERNAL_PORT,
     previewCollector,
     toolHistory,
+    sleepPrevention,
     onCreateSession: (tool, cwd) => {
       if (!isValidToolName(tool)) {
         throw new Error(`Invalid tool name: ${tool}`);
@@ -4802,6 +5167,7 @@ async function main() {
   });
   scheduleShutdown();
   function cleanup() {
+    sleepPrevention.cleanupSync();
     previewCollector.close();
     registry.stopHealthChecks();
     sessionStore.flush();
@@ -4809,11 +5175,11 @@ async function main() {
     internalApi.close();
     dashboardServer.close();
     try {
-      unlinkSync(getPidPath());
+      unlinkSync2(getPidPath());
     } catch {
     }
     try {
-      unlinkSync(getHubConfigPath());
+      unlinkSync2(getHubConfigPath());
     } catch {
     }
   }