@agenticmail/core 0.5.23 → 0.5.25

package/dist/index.d.ts

@@ -1412,86 +1412,50 @@ declare class DependencyChecker {
 type InstallProgress = (message: string) => void;
 /**
  * DependencyInstaller handles installing all external dependencies.
- * Everything is auto-installed — no optional deps, no manual steps.
+ * Uses Colima + Docker CLI on macOS (no Docker Desktop GUI).
+ * Uses Docker Engine directly on Linux.
  */
 declare class DependencyInstaller {
     private onProgress;
-    private _firstLaunchMode;
     constructor(onProgress?: InstallProgress);
     /**
      * Ensure Docker is installed AND the daemon is running.
-     * Fully automatic — installs, accepts license, starts daemon, waits for ready.
-     * Never asks the user to do anything manually.
      *
      * Flow:
-     *   1. docker CLI + daemon running? → done
-     *   2. docker CLI exists but daemon stopped? → start daemon, wait
-     *   3. Docker.app exists (in /Applications or Caskroom)? → run installer --accept-license, start, wait
-     *   4. Nothing installed? → install via Homebrew or DMG download, then start, wait
+     *   1. docker info works? → done
+     *   2. docker CLI + colima exist but not running? → colima start
+     *   3. Nothing installed? → install via brew (colima + docker) or Docker Engine (Linux)
      */
     installDocker(): Promise<void>;
     /** Check if `docker info` succeeds (CLI + daemon both working). */
     private isDockerReady;
-    /** Check if `docker` CLI is in PATH (daemon may be stopped). */
-    private isDockerCliInstalled;
     /**
-     * Find Docker.app on macOS.
-     * Checks /Applications first, then Homebrew Caskroom.
-     * Validates symlinks aren't broken.
+     * macOS: Install Docker via Colima (CLI-only, no GUI, no license dialogs).
+     * Installs colima + docker + docker-compose via Homebrew, then starts Colima.
      */
-    private findDockerApp;
-    /**
-     * Check if Docker Desktop license has already been accepted.
-     * Returns true if we're confident the user has accepted before.
-     */
-    private isDockerLicenseAccepted;
-    /**
-     * Configure Docker Desktop to run headless after first-time setup.
-     * Call this AFTER Docker has been started and license accepted.
-     * Suppresses UI, dock icon, tips, analytics, and auto-updates.
-     */
-    private configureDockerHeadless;
-    /**
-     * Docker.app exists but CLI isn't available or daemon isn't running.
-     * Runs the built-in installer silently (--accept-license to link CLI tools),
-     * then starts Docker Desktop hidden (no GUI window).
-     */
-    /**
-     * Docker.app exists but daemon isn't running.
-     * Simple approach: if Docker was already running, great. If not, just
-     * tell the user to open Docker and accept the terms themselves.
-     * No GUI manipulation, no programmatic license tricks — just wait.
-     */
-    private setupExistingDockerApp;
+    private installDockerMac;
     /**
-     * Hide Docker Desktop completely — close all windows, hide from dock, make invisible.
-     * Called after starting Docker to ensure the user never sees any Docker UI.
+     * Start Colima and wait for Docker to be ready.
      */
-    private hideDockerWindow;
-    /**
-     * Full Docker Desktop install on macOS.
-     * Tries Homebrew first (cleaner), falls back to DMG download.
-     * After install, tells the user to open Docker and accept the terms.
-     * No GUI manipulation — the user handles Docker themselves.
-     */
-    private installDockerMac;
+    private startColima;
     /**
      * Install Docker Engine on Linux using Docker's official convenience script.
      * Also adds the current user to the docker group for rootless usage.
      */
     private installDockerLinux;
     /**
-     * Start the Docker daemon using multiple strategies.
-     * On macOS: tries Docker Desktop app via `open`, direct binary launch, etc.
-     * On Linux: tries systemctl, service, snap.
+     * Wait for Docker daemon on Linux.
+     */
+    private waitForDockerLinux;
+    /**
+     * Windows: Install Docker via WSL2 + Docker Engine, or guide user to Docker Desktop.
+     * Prefers WSL2 with Docker Engine (no GUI needed).
      */
-    private startDockerDaemon;
+    private installDockerWindows;
     /**
-     * Wait for Docker daemon to be ready.
-     * Cycles through multiple start strategies automatically.
-     * Reports progress as a percentage (0-100).
+     * Wait for Docker daemon on Windows.
      */
-    private waitForDocker;
+    private waitForDockerWindows;
     /**
      * Start the Stalwart mail server Docker container.
      */

package/dist/index.js

@@ -850,14 +850,14 @@ var StalwartAdmin = class {
    * Critical for email deliverability — must match the sending domain.
    */
   async setHostname(domain) {
-    const { readFileSync: readFileSync5, writeFileSync: writeFileSync6 } = await import("fs");
+    const { readFileSync: readFileSync4, writeFileSync: writeFileSync5 } = await import("fs");
     const { homedir: homedir8 } = await import("os");
     const { join: join9 } = await import("path");
     const configPath = join9(homedir8(), ".agenticmail", "stalwart.toml");
     try {
-      let config = readFileSync5(configPath, "utf-8");
+      let config = readFileSync4(configPath, "utf-8");
       config = config.replace(/^hostname\s*=\s*"[^"]*"/m, `hostname = "${domain}"`);
-      writeFileSync6(configPath, config);
+      writeFileSync5(configPath, config);
       console.log(`[Stalwart] Updated hostname to "${domain}" in stalwart.toml`);
     } catch (err) {
       throw new Error(`Failed to set config server.hostname=${domain}`);
@@ -975,12 +975,12 @@ var StalwartAdmin = class {
    * This bypasses the need for a PTR record on the sending IP.
    */
   async configureOutboundRelay(config) {
-    const { readFileSync: readFileSync5, writeFileSync: writeFileSync6 } = await import("fs");
+    const { readFileSync: readFileSync4, writeFileSync: writeFileSync5 } = await import("fs");
     const { homedir: homedir8 } = await import("os");
     const { join: join9 } = await import("path");
     const routeName = config.routeName ?? "gmail";
     const tomlPath = join9(homedir8(), ".agenticmail", "stalwart.toml");
-    let toml = readFileSync5(tomlPath, "utf-8");
+    let toml = readFileSync4(tomlPath, "utf-8");
     toml = toml.replace(/\n\[queue\.route\.gmail\][\s\S]*?(?=\n\[|$)/, "");
     toml = toml.replace(/\n\[queue\.strategy\][\s\S]*?(?=\n\[|$)/, "");
     toml += `
@@ -999,7 +999,7 @@ auth.secret = "${config.password}"
 route = [ { if = "is_local_domain('', rcpt_domain)", then = "'local'" },
            { else = "'${routeName}'" } ]
 `;
-    writeFileSync6(tomlPath, toml, "utf-8");
+    writeFileSync5(tomlPath, toml, "utf-8");
     await this.restartContainer();
   }
 };
@@ -5180,9 +5180,9 @@ var GatewayManager = class {
     const { homedir: homedir8 } = await import("os");
     const backupDir = join4(homedir8(), ".agenticmail");
     const backupPath = join4(backupDir, `dns-backup-${domain}-${Date.now()}.json`);
-    const { writeFileSync: writeFileSync6, mkdirSync: mkdirSync6 } = await import("fs");
-    mkdirSync6(backupDir, { recursive: true });
-    writeFileSync6(backupPath, JSON.stringify({
+    const { writeFileSync: writeFileSync5, mkdirSync: mkdirSync5 } = await import("fs");
+    mkdirSync5(backupDir, { recursive: true });
+    writeFileSync5(backupPath, JSON.stringify({
       domain,
       zoneId: zone.id,
       backedUpAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -5813,7 +5813,7 @@ var RELAY_PRESETS = {
 
 // src/setup/index.ts
 import { randomBytes as randomBytes2 } from "crypto";
-import { existsSync as existsSync6, readFileSync as readFileSync4, writeFileSync as writeFileSync5, mkdirSync as mkdirSync5, chmodSync } from "fs";
+import { existsSync as existsSync6, readFileSync as readFileSync3, writeFileSync as writeFileSync4, mkdirSync as mkdirSync4, chmodSync } from "fs";
 import { join as join8 } from "path";
 import { homedir as homedir7 } from "os";
 
@@ -5894,7 +5894,7 @@ var DependencyChecker = class {
 
 // src/setup/installer.ts
 import { execFileSync as execFileSync2, execSync, spawn as spawnChild } from "child_process";
-import { existsSync as existsSync4, readdirSync, lstatSync, readlinkSync, writeFileSync as writeFileSync3, readFileSync as readFileSync2 } from "fs";
+import { existsSync as existsSync4 } from "fs";
 import { writeFile, rename, chmod as chmod2, mkdir as mkdir2, unlink } from "fs/promises";
 import { join as join6 } from "path";
 import { homedir as homedir5, platform as platform2, arch as arch2 } from "os";
@@ -6034,26 +6034,17 @@ function runSilent(command, args, opts = {}) {
     child.on("error", reject);
   });
 }
-function existsReal(p) {
+function hasHomebrew() {
   try {
-    const stat = lstatSync(p);
-    if (stat.isSymbolicLink()) {
-      try {
-        const target = readlinkSync(p);
-        const resolved = target.startsWith("/") ? target : join6(p, "..", target);
-        return existsSync4(resolved);
-      } catch {
-        return false;
-      }
-    }
+    execFileSync2("brew", ["--version"], { timeout: 5e3, stdio: "ignore" });
     return true;
   } catch {
     return false;
   }
 }
-function hasHomebrew() {
+function hasCommand(cmd) {
   try {
-    execFileSync2("brew", ["--version"], { timeout: 5e3, stdio: "ignore" });
+    execFileSync2("which", [cmd], { timeout: 5e3, stdio: "ignore" });
     return true;
   } catch {
     return false;
@@ -6061,41 +6052,27 @@ function hasHomebrew() {
 }
 var DependencyInstaller = class {
   onProgress;
-  _firstLaunchMode = false;
   constructor(onProgress) {
     this.onProgress = onProgress ?? (() => {
     });
   }
   /**
    * Ensure Docker is installed AND the daemon is running.
-   * Fully automatic — installs, accepts license, starts daemon, waits for ready.
-   * Never asks the user to do anything manually.
    *
    * Flow:
-   *   1. docker CLI + daemon running? → done
-   *   2. docker CLI exists but daemon stopped? → start daemon, wait
-   *   3. Docker.app exists (in /Applications or Caskroom)? → run installer --accept-license, start, wait
-   *   4. Nothing installed? → install via Homebrew or DMG download, then start, wait
+   *   1. docker info works? → done
+   *   2. docker CLI + colima exist but not running? → colima start
+   *   3. Nothing installed? → install via brew (colima + docker) or Docker Engine (Linux)
    */
   async installDocker() {
     if (this.isDockerReady()) return;
-    if (this.isDockerCliInstalled()) {
-      this.onProgress("__progress__:10:Docker installed \u2014 starting the engine...");
-      this.startDockerDaemon();
-      await this.waitForDocker();
-      return;
-    }
-    const dockerApp = this.findDockerApp();
-    if (dockerApp) {
-      this.onProgress("__progress__:10:Setting up mail server engine...");
-      await this.setupExistingDockerApp(dockerApp);
-      return;
-    }
     const os = platform2();
     if (os === "darwin") {
       await this.installDockerMac();
     } else if (os === "linux") {
       await this.installDockerLinux();
+    } else if (os === "win32") {
+      await this.installDockerWindows();
     } else {
       throw new Error(
         `Docker auto-install isn't supported on ${os} yet. Install it from https://docs.docker.com/get-docker/ and try again.`
@@ -6111,288 +6088,92 @@ var DependencyInstaller = class {
       return false;
     }
   }
-  /** Check if `docker` CLI is in PATH (daemon may be stopped). */
-  isDockerCliInstalled() {
-    try {
-      execFileSync2("docker", ["--version"], { timeout: 5e3, stdio: "ignore" });
-      return true;
-    } catch {
-      return false;
-    }
-  }
   /**
-   * Find Docker.app on macOS.
-   * Checks /Applications first, then Homebrew Caskroom.
-   * Validates symlinks aren't broken.
+   * macOS: Install Docker via Colima (CLI-only, no GUI, no license dialogs).
+   * Installs colima + docker + docker-compose via Homebrew, then starts Colima.
    */
-  findDockerApp() {
-    if (existsReal("/Applications/Docker.app")) {
-      return "/Applications/Docker.app";
-    }
-    const caskroomBases = [
-      "/opt/homebrew/Caskroom",
-      "/usr/local/Caskroom"
-    ];
-    const caskNames = ["docker-desktop", "docker"];
-    for (const base of caskroomBases) {
-      for (const name of caskNames) {
-        const caskroom = join6(base, name);
-        if (!existsSync4(caskroom)) continue;
-        try {
-          const versions = readdirSync(caskroom).filter((d) => !d.startsWith("."));
-          for (const ver of versions) {
-            const appPath = join6(caskroom, ver, "Docker.app");
-            if (existsReal(appPath)) return appPath;
-          }
-        } catch {
-        }
-      }
+  async installDockerMac() {
+    if (hasCommand("colima") && hasCommand("docker")) {
+      this.onProgress("__progress__:10:Starting container engine...");
+      await this.startColima();
+      return;
     }
-    return null;
-  }
-  /**
-   * Check if Docker Desktop license has already been accepted.
-   * Returns true if we're confident the user has accepted before.
-   */
-  isDockerLicenseAccepted() {
-    try {
-      const systemFile = "/Library/Application Support/com.docker.docker/install-settings.json";
-      if (existsSync4(systemFile)) {
-        const raw = readFileSync2(systemFile, "utf-8");
-        const data = JSON.parse(raw);
-        if (data.acceptLicense) return true;
-      }
-    } catch {
+    if (!hasHomebrew()) {
+      throw new Error(
+        "Homebrew is required to install Docker on macOS.\nInstall it from https://brew.sh and try again."
+      );
     }
-    try {
-      const settingsFile = join6(process.env.HOME || "", "Library/Group Containers/group.com.docker/settings-store.json");
-      if (existsSync4(settingsFile)) {
-        return true;
-      }
-    } catch {
+    this.onProgress("__progress__:5:Installing container engine...");
+    const brewResult = await runSilent(
+      "brew",
+      ["install", "colima", "docker", "docker-compose"],
+      { timeout: 6e5 }
+    );
+    if (brewResult.exitCode !== 0) {
+      throw new Error(
+        "Failed to install Docker via Homebrew.\nTry running manually: brew install colima docker docker-compose\n" + brewResult.fullOutput.slice(-500)
+      );
     }
-    return false;
-  }
-  /**
-   * Configure Docker Desktop to run headless after first-time setup.
-   * Call this AFTER Docker has been started and license accepted.
-   * Suppresses UI, dock icon, tips, analytics, and auto-updates.
-   */
-  configureDockerHeadless() {
-    try {
-      const userDockerDir = join6(process.env.HOME || "", "Library/Group Containers/group.com.docker");
-      const settingsFile = join6(userDockerDir, "settings-store.json");
-      const headlessDefaults = {
-        AutoStart: false,
-        // Don't auto-start on login (we start it ourselves)
-        OpenUIOnStartupDisabled: true,
-        // Don't show dashboard on start
-        TipShown: true,
-        // Don't show tips/welcome
-        SUAutomaticallyUpdate: false,
-        // Don't nag about updates
-        AnalyticsEnabled: false
-        // No analytics prompts
-      };
-      if (existsSync4(settingsFile)) {
-        const raw = readFileSync2(settingsFile, "utf-8");
-        try {
-          const settings = JSON.parse(raw);
-          let changed = false;
-          for (const [key, val] of Object.entries(headlessDefaults)) {
-            if (settings[key] !== val) {
-              settings[key] = val;
-              changed = true;
-            }
-          }
-          if (changed) {
-            writeFileSync3(settingsFile, JSON.stringify(settings, null, 2));
-          }
-        } catch {
-        }
-      } else if (existsSync4(userDockerDir)) {
-        writeFileSync3(settingsFile, JSON.stringify(headlessDefaults, null, 2));
-      }
-    } catch {
+    if (!hasCommand("colima") || !hasCommand("docker")) {
+      throw new Error(
+        "Installation completed but colima/docker not found in PATH.\nTry running manually: brew install colima docker docker-compose"
+      );
     }
+    this.onProgress("__progress__:50:Starting container engine...");
+    await this.startColima();
   }
   /**
-   * Docker.app exists but CLI isn't available or daemon isn't running.
-   * Runs the built-in installer silently (--accept-license to link CLI tools),
-   * then starts Docker Desktop hidden (no GUI window).
+   * Start Colima and wait for Docker to be ready.
    */
-  /**
-   * Docker.app exists but daemon isn't running.
-   * Simple approach: if Docker was already running, great. If not, just
-   * tell the user to open Docker and accept the terms themselves.
-   * No GUI manipulation, no programmatic license tricks — just wait.
-   */
-  async setupExistingDockerApp(_appPath) {
+  async startColima() {
     if (this.isDockerReady()) {
       this.onProgress("__progress__:100:Engine is ready!");
       return;
     }
-    this.onProgress("Open Docker Desktop and accept the license agreement, then we'll continue automatically...");
-    const totalTime = 6e5;
+    const startResult = await runSilent(
+      "colima",
+      ["start", "--cpu", "2", "--memory", "2", "--disk", "10"],
+      { timeout: 3e5 }
+    );
+    if (startResult.exitCode !== 0) {
+      throw new Error(
+        "Failed to start Colima. Try running manually: colima start\n" + startResult.fullOutput.slice(-500)
+      );
+    }
+    const totalTime = 6e4;
     const start = Date.now();
     while (Date.now() - start < totalTime) {
-      try {
-        execFileSync2("docker", ["info"], { timeout: 5e3, stdio: "ignore" });
+      if (this.isDockerReady()) {
         this.onProgress("__progress__:100:Engine is ready!");
-        this.configureDockerHeadless();
-        this.hideDockerWindow();
         return;
-      } catch {
       }
       const elapsed = Date.now() - start;
-      const pct = Math.min(95, Math.round(elapsed / totalTime * 100));
-      const msgs = [
-        "Open Docker Desktop and accept the license to continue...",
-        "Waiting for Docker to be ready...",
-        "Accept the terms in Docker Desktop to continue...",
-        "Still waiting for Docker..."
-      ];
-      const msgIdx = Math.floor(elapsed / 8e3) % msgs.length;
-      this.onProgress(`__progress__:${pct}:${msgs[msgIdx]}`);
-      await new Promise((r) => setTimeout(r, 3e3));
+      const pct = Math.min(95, 50 + Math.round(elapsed / totalTime * 50));
+      this.onProgress(`__progress__:${pct}:Waiting for engine...`);
+      await new Promise((r) => setTimeout(r, 2e3));
     }
     throw new Error(
-      "Docker did not start. Open Docker Desktop from your Applications folder, accept the license agreement, then run this command again."
+      "Docker engine did not start in time. Try running manually: colima start"
     );
   }
   /**
-   * Hide Docker Desktop completely — close all windows, hide from dock, make invisible.
-   * Called after starting Docker to ensure the user never sees any Docker UI.
-   */
-  hideDockerWindow() {
-    try {
-      execSync(
-        `osascript -e 'tell application "System Events" to tell process "Docker Desktop" to set visible to false' 2>/dev/null`,
-        { timeout: 5e3, stdio: "ignore" }
-      );
-    } catch {
-    }
-    try {
-      execSync(
-        `osascript -e 'tell application "Docker Desktop" to close every window' 2>/dev/null`,
-        { timeout: 5e3, stdio: "ignore" }
-      );
-    } catch {
-    }
-    try {
-      execSync(
-        `osascript -e 'tell application "Docker" to close every window' 2>/dev/null`,
-        { timeout: 5e3, stdio: "ignore" }
-      );
-    } catch {
-    }
-    const dockerApp = this.findDockerApp();
-    if (dockerApp) {
-      const plistPath = join6(dockerApp, "Contents", "Info.plist");
-      try {
-        const plistContent = readFileSync2(plistPath, "utf-8");
-        if (!plistContent.includes("LSUIElement")) {
-          execSync(
-            `/usr/libexec/PlistBuddy -c "Add :LSUIElement bool true" "${plistPath}" 2>/dev/null`,
-            { timeout: 5e3, stdio: "ignore" }
-          );
-        } else if (!plistContent.includes("<key>LSUIElement</key>\n	<true/>") && !plistContent.includes("<key>LSUIElement</key><true/>")) {
-          execSync(
-            `/usr/libexec/PlistBuddy -c "Set :LSUIElement true" "${plistPath}" 2>/dev/null`,
-            { timeout: 5e3, stdio: "ignore" }
-          );
-        }
-      } catch {
-      }
-    }
-  }
-  /**
-   * Full Docker Desktop install on macOS.
-   * Tries Homebrew first (cleaner), falls back to DMG download.
-   * After install, tells the user to open Docker and accept the terms.
-   * No GUI manipulation — the user handles Docker themselves.
+   * Install Docker Engine on Linux using Docker's official convenience script.
+   * Also adds the current user to the docker group for rootless usage.
    */
-  async installDockerMac() {
-    let installed = false;
-    if (hasHomebrew()) {
-      this.onProgress("__progress__:5:Installing Docker Desktop...");
-      try {
-        const brewResult = await runSilent(
-          "brew",
-          ["install", "--cask", "docker"],
-          { timeout: 6e5 }
-        );
-        if (brewResult.exitCode === 0 && this.findDockerApp()) {
-          installed = true;
-        }
-      } catch {
-      }
-    }
-    if (!installed) {
-      const cpu = arch2();
-      const archName = cpu === "arm64" ? "arm64" : "amd64";
-      const dmgUrl = `https://desktop.docker.com/mac/main/${archName}/Docker.dmg`;
-      const dmgPath = "/tmp/Docker.dmg";
-      this.onProgress("__progress__:5:Downloading Docker Desktop...");
-      const dlResult = await runSilent("curl", [
-        "-fSL",
-        "-o",
-        dmgPath,
-        dmgUrl
-      ], { timeout: 6e5 });
-      if (dlResult.exitCode !== 0) {
-        throw new Error("Failed to download Docker Desktop. Check your internet connection and try again.");
-      }
-      this.onProgress("__progress__:40:Installing Docker Desktop...");
+  async installDockerLinux() {
+    if (hasCommand("docker")) {
+      this.onProgress("__progress__:10:Starting Docker service...");
       try {
-        try {
-          execSync("hdiutil detach /Volumes/Docker 2>/dev/null", { timeout: 1e4, stdio: "ignore" });
-        } catch {
-        }
-        execSync(`hdiutil attach "${dmgPath}" -nobrowse -quiet`, { timeout: 3e4, stdio: "ignore" });
+        execSync("sudo systemctl start docker", { timeout: 15e3, stdio: "ignore" });
       } catch {
-        throw new Error("Failed to mount Docker DMG. The download may be corrupted \u2014 try again.");
-      }
-      if (!existsSync4("/Applications/Docker.app")) {
         try {
-          execSync('cp -R "/Volumes/Docker/Docker.app" /Applications/', { timeout: 6e4, stdio: "ignore" });
+          execSync("sudo service docker start", { timeout: 15e3, stdio: "ignore" });
         } catch {
-          throw new Error("Failed to install. You may need to run this with admin privileges.");
         }
       }
-      try {
-        execSync("hdiutil detach /Volumes/Docker -quiet", { timeout: 15e3, stdio: "ignore" });
-      } catch {
-      }
-      try {
-        await unlink(dmgPath);
-      } catch {
-      }
-    }
-    try {
-      execSync(`osascript -e 'quit app "Docker Desktop"' 2>/dev/null`, { timeout: 5e3, stdio: "ignore" });
-    } catch {
-    }
-    try {
-      execSync(`osascript -e 'quit app "Docker"' 2>/dev/null`, { timeout: 5e3, stdio: "ignore" });
-    } catch {
-    }
-    try {
-      execSync("pkill -f Docker.app 2>/dev/null", { timeout: 5e3, stdio: "ignore" });
-    } catch {
-    }
-    await new Promise((r) => setTimeout(r, 2e3));
-    const appPath = this.findDockerApp();
-    if (!appPath) {
-      throw new Error("Docker Desktop was installed but could not be found. Try again.");
+      await this.waitForDockerLinux();
+      return;
     }
-    await this.setupExistingDockerApp(appPath);
-  }
-  /**
-   * Install Docker Engine on Linux using Docker's official convenience script.
-   * Also adds the current user to the docker group for rootless usage.
-   */
-  async installDockerLinux() {
     this.onProgress("__progress__:5:Installing Docker Engine...");
     const dlResult = await runShellWithRollingOutput(
       "curl -fsSL https://get.docker.com -o /tmp/install-docker.sh && sudo sh /tmp/install-docker.sh",
@@ -6424,172 +6205,126 @@ var DependencyInstaller = class {
       } catch {
       }
     }
-    await this.waitForDocker();
+    await this.waitForDockerLinux();
   }
   /**
-   * Start the Docker daemon using multiple strategies.
-   * On macOS: tries Docker Desktop app via `open`, direct binary launch, etc.
-   * On Linux: tries systemctl, service, snap.
+   * Wait for Docker daemon on Linux.
    */
-  startDockerDaemon(strategy) {
-    const os = platform2();
-    if (os === "darwin") {
-      const dockerApp = this.findDockerApp();
-      switch (strategy) {
-        case "cli":
-          try {
-            execSync("docker context use default 2>/dev/null; docker info", { timeout: 5e3, stdio: "ignore" });
-          } catch {
-          }
-          break;
-        case "reopen":
-          try {
-            execSync(`osascript -e 'quit app "Docker"'`, { timeout: 5e3, stdio: "ignore" });
-          } catch {
-          }
-          try {
-            execFileSync2("sleep", ["2"], { timeout: 5e3, stdio: "ignore" });
-          } catch {
-          }
-          if (dockerApp) {
-            try {
-              execFileSync2("open", ["-g", "-j", dockerApp], { timeout: 1e4, stdio: "ignore" });
-            } catch {
-            }
-          } else {
-            try {
-              execFileSync2("open", ["-g", "-j", "-a", "Docker"], { timeout: 1e4, stdio: "ignore" });
-            } catch {
-            }
-          }
-          break;
-        case "background": {
-          const appBin = dockerApp ? join6(dockerApp, "Contents", "MacOS", "Docker") : "/Applications/Docker.app/Contents/MacOS/Docker";
-          try {
-            if (existsSync4(appBin)) {
-              execSync(`"${appBin}" &`, { timeout: 5e3, stdio: "ignore", shell: "sh" });
-            }
-          } catch {
-          }
-          break;
-        }
-        case "install": {
-          const installBin = dockerApp ? join6(dockerApp, "Contents", "MacOS", "install") : "/Applications/Docker.app/Contents/MacOS/install";
-          if (existsSync4(installBin)) {
-            const user = process.env.USER || "nobody";
-            try {
-              execSync(`"${installBin}" --accept-license --user=${user}`, { timeout: 6e4, stdio: "ignore" });
-            } catch {
-            }
-          }
-          if (dockerApp) {
-            try {
-              execFileSync2("open", ["-g", "-j", dockerApp], { timeout: 1e4, stdio: "ignore" });
-            } catch {
-            }
-          }
-          break;
+  async waitForDockerLinux() {
+    const totalTime = 6e4;
+    const start = Date.now();
+    while (Date.now() - start < totalTime) {
+      if (this.isDockerReady()) {
+        this.onProgress("__progress__:100:Docker is ready!");
+        return;
+      }
+      const elapsed = Date.now() - start;
+      const pct = Math.min(95, Math.round(elapsed / totalTime * 100));
+      this.onProgress(`__progress__:${pct}:Waiting for Docker...`);
+      await new Promise((r) => setTimeout(r, 2e3));
+    }
+    throw new Error("Docker did not start. Try: sudo systemctl start docker");
+  }
+  /**
+   * Windows: Install Docker via WSL2 + Docker Engine, or guide user to Docker Desktop.
+   * Prefers WSL2 with Docker Engine (no GUI needed).
+   */
+  async installDockerWindows() {
+    if (hasCommand("docker")) {
+      if (this.isDockerReady()) {
+        this.onProgress("__progress__:100:Engine is ready!");
+        return;
+      }
+      this.onProgress("__progress__:10:Starting Docker...");
+      try {
+        execSync("net start com.docker.service", { timeout: 3e4, stdio: "ignore" });
+      } catch {
+      }
+      try {
+        const programFiles = process.env["ProgramFiles"] || "C:\\Program Files";
+        const dockerExe = join6(programFiles, "Docker", "Docker", "Docker Desktop.exe");
+        if (existsSync4(dockerExe)) {
+          execSync(`start "" "${dockerExe}"`, { timeout: 1e4, stdio: "ignore", shell: "cmd.exe" });
         }
-        default:
-          if (dockerApp) {
-            try {
-              execFileSync2("open", ["-g", "-j", dockerApp], { timeout: 1e4, stdio: "ignore" });
-            } catch {
-            }
-          } else {
-            try {
-              execFileSync2("open", ["-g", "-j", "-a", "Docker"], { timeout: 1e4, stdio: "ignore" });
-            } catch {
-            }
-          }
+      } catch {
       }
-    } else if (os === "linux") {
-      switch (strategy) {
-        case "snap":
-          try {
-            execFileSync2("sudo", ["snap", "start", "docker"], { timeout: 15e3, stdio: "ignore" });
-          } catch {
-          }
-          break;
-        case "service":
+      await this.waitForDockerWindows();
+      return;
+    }
+    let hasWsl = false;
+    try {
+      const wslResult = execSync("wsl --status", { timeout: 1e4, stdio: ["ignore", "pipe", "ignore"] }).toString();
+      hasWsl = wslResult.length > 0;
+    } catch {
+    }
+    if (hasWsl) {
+      this.onProgress("__progress__:5:Installing Docker Engine in WSL...");
+      try {
+        const wslResult = await runSilent(
+          "wsl",
+          ["-e", "sh", "-c", "curl -fsSL https://get.docker.com | sh"],
+          { timeout: 3e5 }
+        );
+        if (wslResult.exitCode === 0) {
           try {
-            execFileSync2("sudo", ["service", "docker", "start"], { timeout: 15e3, stdio: "ignore" });
+            execSync("wsl -e sudo service docker start", { timeout: 15e3, stdio: "ignore" });
           } catch {
           }
-          break;
-        default:
-          try {
-            execFileSync2("sudo", ["systemctl", "start", "docker"], { timeout: 15e3, stdio: "ignore" });
-          } catch {
+          await this.waitForDockerWindows();
+          return;
+        }
+      } catch {
+      }
+    }
+    let hasWinget = false;
+    try {
+      execSync("winget --version", { timeout: 5e3, stdio: "ignore" });
+      hasWinget = true;
+    } catch {
+    }
+    if (hasWinget) {
+      this.onProgress("__progress__:5:Installing Docker Desktop...");
+      const wingetResult = await runSilent(
+        "winget",
+        ["install", "-e", "--id", "Docker.DockerDesktop", "--accept-source-agreements", "--accept-package-agreements"],
+        { timeout: 6e5 }
+      );
+      if (wingetResult.exitCode === 0) {
+        this.onProgress("__progress__:70:Docker Desktop installed. Starting...");
+        try {
+          const programFiles = process.env["ProgramFiles"] || "C:\\Program Files";
+          const dockerExe = join6(programFiles, "Docker", "Docker", "Docker Desktop.exe");
+          if (existsSync4(dockerExe)) {
+            execSync(`start "" "${dockerExe}"`, { timeout: 1e4, stdio: "ignore", shell: "cmd.exe" });
           }
+        } catch {
+        }
+        await this.waitForDockerWindows();
+        return;
       }
     }
+    throw new Error(
+      'Could not auto-install Docker on Windows.\nPlease install Docker Desktop from https://docs.docker.com/desktop/install/windows-install/\nOr install WSL2 and Docker Engine: wsl --install && wsl -e sh -c "curl -fsSL https://get.docker.com | sh"'
+    );
   }
   /**
-   * Wait for Docker daemon to be ready.
-   * Cycles through multiple start strategies automatically.
-   * Reports progress as a percentage (0-100).
+   * Wait for Docker daemon on Windows.
    */
-  async waitForDocker() {
-    const os = platform2();
-    const strategies = os === "darwin" ? ["default", "cli", "reopen", "background", "install"] : ["default", "service", "snap"];
-    const totalTime = 3e5;
-    const perStrategyTime = Math.floor(totalTime / strategies.length);
+  async waitForDockerWindows() {
+    const totalTime = 12e4;
     const start = Date.now();
-    let strategyIdx = 0;
-    this.onProgress("__progress__:0:Starting Docker...");
     while (Date.now() - start < totalTime) {
-      try {
-        execFileSync2("docker", ["info"], { timeout: 5e3, stdio: "ignore" });
+      if (this.isDockerReady()) {
         this.onProgress("__progress__:100:Docker is ready!");
         return;
-      } catch {
       }
       const elapsed = Date.now() - start;
       const pct = Math.min(95, Math.round(elapsed / totalTime * 100));
-      if (this._firstLaunchMode) {
-        const msgs = [
-          "Please accept the license agreement in the Docker window...",
-          "Waiting for you to accept the terms...",
-          "Accept the agreement to continue...",
-          "Still waiting..."
-        ];
-        const msgIdx = Math.floor(elapsed / 8e3) % msgs.length;
-        this.onProgress(`__progress__:${pct}:${msgs[msgIdx]}`);
-      } else {
-        const currentStrategyElapsed = elapsed - strategyIdx * perStrategyTime;
-        if (currentStrategyElapsed >= perStrategyTime && strategyIdx < strategies.length - 1) {
-          strategyIdx++;
-          const strategy = strategies[strategyIdx];
-          const msgs = {
-            cli: "Checking engine...",
-            reopen: "Restarting engine...",
-            background: "Trying direct launch...",
-            install: "Re-running installer...",
-            service: "Trying service command...",
-            snap: "Trying snap..."
-          };
-          this.onProgress(`__progress__:${pct}:${msgs[strategy] || "Trying another approach..."}`);
-          this.startDockerDaemon(strategy);
-        } else {
-          const msgs = [
-            "Starting engine...",
-            "Waiting for engine...",
-            "Loading...",
-            "Almost there...",
-            "Still starting up...",
-            "First launch takes a bit longer...",
-            "Hang tight..."
-          ];
-          const msgIdx = Math.floor(elapsed / 1e4) % msgs.length;
-          this.onProgress(`__progress__:${pct}:${msgs[msgIdx]}`);
-        }
-        if (os === "darwin") this.hideDockerWindow();
-      }
+      this.onProgress(`__progress__:${pct}:Waiting for Docker...`);
       await new Promise((r) => setTimeout(r, 3e3));
     }
     throw new Error(
-      "Engine could not be started after trying all available methods. If this is your first time, open Docker from your Applications folder, accept the license agreement, then run this command again."
+      "Docker did not start in time.\nMake sure Docker Desktop is running, then try again."
     );
   }
   /**
@@ -6599,12 +6334,24 @@ var DependencyInstaller = class {
     if (!existsSync4(composePath)) {
       throw new Error(`docker-compose.yml not found at: ${composePath}`);
     }
-    try {
-      execFileSync2("docker", ["info"], { timeout: 1e4, stdio: "ignore" });
-    } catch {
+    if (!this.isDockerReady()) {
       this.onProgress("Starting Docker...");
-      this.startDockerDaemon();
-      await this.waitForDocker();
+      const os = platform2();
+      if (os === "darwin") {
+        await this.startColima();
+      } else if (os === "win32") {
+        await this.waitForDockerWindows();
+      } else {
+        try {
+          execSync("sudo systemctl start docker", { timeout: 15e3, stdio: "ignore" });
+        } catch {
+          try {
+            execSync("sudo service docker start", { timeout: 15e3, stdio: "ignore" });
+          } catch {
+          }
+        }
+        await this.waitForDockerLinux();
+      }
     }
     this.onProgress("__progress__:10:Pulling mail server image...");
     const composeResult = await runWithRollingOutput("docker", ["compose", "-f", composePath, "up", "-d"], { timeout: 12e4 });
@@ -6638,25 +6385,31 @@ var DependencyInstaller = class {
    * Returns the path to the installed binary.
    */
   async installCloudflared() {
+    const os = platform2();
     const binDir = join6(homedir5(), ".agenticmail", "bin");
-    const binPath = join6(binDir, "cloudflared");
+    const binName = os === "win32" ? "cloudflared.exe" : "cloudflared";
+    const binPath = join6(binDir, binName);
     if (existsSync4(binPath)) {
       return binPath;
     }
     try {
-      const sysPath = execFileSync2("which", ["cloudflared"], { timeout: 5e3, stdio: ["ignore", "pipe", "ignore"] }).toString().trim();
+      const whichCmd = os === "win32" ? "where" : "which";
+      const sysPath = execFileSync2(whichCmd, ["cloudflared"], { timeout: 5e3, stdio: ["ignore", "pipe", "ignore"] }).toString().trim().split("\n")[0];
       if (sysPath && existsSync4(sysPath)) return sysPath;
     } catch {
     }
     this.onProgress("Downloading cloudflared...");
     await mkdir2(binDir, { recursive: true });
-    const os = platform2();
     const cpu = arch2();
     const archName = cpu === "arm64" ? "arm64" : "amd64";
-    const isTgz = os === "darwin";
-    const ext = isTgz ? ".tgz" : "";
-    const downloadUrl = `https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-${os}-${archName}${ext}`;
-    if (os !== "darwin" && os !== "linux") {
+    let downloadUrl;
+    if (os === "darwin") {
+      downloadUrl = `https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-darwin-${archName}.tgz`;
+    } else if (os === "linux") {
+      downloadUrl = `https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-${archName}`;
+    } else if (os === "win32") {
+      downloadUrl = `https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-windows-${archName}.exe`;
+    } else {
       throw new Error(`Unsupported platform: ${os}/${cpu}`);
     }
     const response = await fetch(downloadUrl);
@@ -6664,7 +6417,7 @@ var DependencyInstaller = class {
       throw new Error(`Failed to download cloudflared: ${response.statusText}`);
     }
     const buffer = Buffer.from(await response.arrayBuffer());
-    if (isTgz) {
+    if (os === "darwin") {
       const tgzPath = join6(binDir, "cloudflared.tgz");
       await writeFile(tgzPath, buffer);
       try {
@@ -6679,7 +6432,7 @@ var DependencyInstaller = class {
     } else {
       const tmpPath = binPath + ".tmp";
       await writeFile(tmpPath, buffer);
-      await chmod2(tmpPath, 493);
+      if (os !== "win32") await chmod2(tmpPath, 493);
       await rename(tmpPath, binPath);
     }
     if (!existsSync4(binPath)) {
@@ -6700,7 +6453,7 @@ var DependencyInstaller = class {
 
 // src/setup/service.ts
 import { execFileSync as execFileSync3, execSync as execSync2 } from "child_process";
-import { existsSync as existsSync5, readFileSync as readFileSync3, writeFileSync as writeFileSync4, unlinkSync, mkdirSync as mkdirSync4 } from "fs";
+import { existsSync as existsSync5, readFileSync as readFileSync2, writeFileSync as writeFileSync3, unlinkSync, mkdirSync as mkdirSync3 } from "fs";
 import { join as join7 } from "path";
 import { homedir as homedir6, platform as platform3 } from "os";
 var PLIST_LABEL = "com.agenticmail.server";
@@ -6763,7 +6516,7 @@ var ServiceManager = class {
     const dataDir = join7(homedir6(), ".agenticmail");
     const entryCache = join7(dataDir, "api-entry.path");
     if (existsSync5(entryCache)) {
-      const cached = readFileSync3(entryCache, "utf-8").trim();
+      const cached = readFileSync2(entryCache, "utf-8").trim();
       if (existsSync5(cached)) return cached;
     }
     throw new Error("Could not find @agenticmail/api entry point. Run `agenticmail start` first to populate the cache.");
@@ -6773,8 +6526,8 @@ var ServiceManager = class {
    */
   cacheApiEntryPath(entryPath) {
     const dataDir = join7(homedir6(), ".agenticmail");
-    if (!existsSync5(dataDir)) mkdirSync4(dataDir, { recursive: true });
-    writeFileSync4(join7(dataDir, "api-entry.path"), entryPath);
+    if (!existsSync5(dataDir)) mkdirSync3(dataDir, { recursive: true });
+    writeFileSync3(join7(dataDir, "api-entry.path"), entryPath);
   }
   /**
    * Get the current package version.
@@ -6792,7 +6545,7 @@ var ServiceManager = class {
       }
       for (const p of pkgPaths) {
         if (existsSync5(p)) {
-          const pkg = JSON.parse(readFileSync3(p, "utf-8"));
+          const pkg = JSON.parse(readFileSync2(p, "utf-8"));
           if (pkg.version) return pkg.version;
         }
       }
@@ -6807,7 +6560,7 @@ var ServiceManager = class {
   generateStartScript(nodePath, apiEntry) {
     const scriptPath = join7(homedir6(), ".agenticmail", "bin", "start-server.sh");
     const scriptDir = join7(homedir6(), ".agenticmail", "bin");
-    if (!existsSync5(scriptDir)) mkdirSync4(scriptDir, { recursive: true });
+    if (!existsSync5(scriptDir)) mkdirSync3(scriptDir, { recursive: true });
     const script = [
       "#!/bin/bash",
       "# AgenticMail auto-start script",
@@ -6858,7 +6611,7 @@ var ServiceManager = class {
       `log "Starting API server: ${nodePath} ${apiEntry}"`,
       `exec "${nodePath}" "${apiEntry}"`
     ].join("\n") + "\n";
-    writeFileSync4(scriptPath, script, { mode: 493 });
+    writeFileSync3(scriptPath, script, { mode: 493 });
     return scriptPath;
   }
   /**
@@ -6871,9 +6624,9 @@ var ServiceManager = class {
    * - Service version tracking in env vars
    */
   generatePlist(nodePath, apiEntry, configPath) {
-    const config = JSON.parse(readFileSync3(configPath, "utf-8"));
+    const config = JSON.parse(readFileSync2(configPath, "utf-8"));
     const logDir = join7(homedir6(), ".agenticmail", "logs");
-    if (!existsSync5(logDir)) mkdirSync4(logDir, { recursive: true });
+    if (!existsSync5(logDir)) mkdirSync3(logDir, { recursive: true });
     const version = this.getVersion();
     const startScript = this.generateStartScript(nodePath, apiEntry);
     return `<?xml version="1.0" encoding="UTF-8"?>
@@ -6969,7 +6722,7 @@ var ServiceManager = class {
    * - Proper dependency ordering
    */
   generateSystemdUnit(nodePath, apiEntry, configPath) {
-    const config = JSON.parse(readFileSync3(configPath, "utf-8"));
+    const config = JSON.parse(readFileSync2(configPath, "utf-8"));
     const dataDir = config.dataDir || join7(homedir6(), ".agenticmail");
     const version = this.getVersion();
     const startScript = this.generateStartScript(nodePath, apiEntry);
@@ -7024,7 +6777,7 @@ WantedBy=default.target
     const servicePath = this.getServicePath();
     if (this.os === "darwin") {
       const dir = join7(homedir6(), "Library", "LaunchAgents");
-      if (!existsSync5(dir)) mkdirSync4(dir, { recursive: true });
+      if (!existsSync5(dir)) mkdirSync3(dir, { recursive: true });
       if (existsSync5(servicePath)) {
         try {
           execFileSync3("launchctl", ["unload", servicePath], { timeout: 1e4, stdio: "ignore" });
@@ -7032,7 +6785,7 @@ WantedBy=default.target
         }
       }
       const plist = this.generatePlist(nodePath, apiEntry, configPath);
-      writeFileSync4(servicePath, plist);
+      writeFileSync3(servicePath, plist);
       try {
         execFileSync3("launchctl", ["load", servicePath], { timeout: 1e4, stdio: "ignore" });
       } catch (err) {
@@ -7041,9 +6794,9 @@ WantedBy=default.target
       return { installed: true, message: `Service installed at ${servicePath}` };
     } else if (this.os === "linux") {
       const dir = join7(homedir6(), ".config", "systemd", "user");
-      if (!existsSync5(dir)) mkdirSync4(dir, { recursive: true });
+      if (!existsSync5(dir)) mkdirSync3(dir, { recursive: true });
       const unit = this.generateSystemdUnit(nodePath, apiEntry, configPath);
-      writeFileSync4(servicePath, unit);
+      writeFileSync3(servicePath, unit);
       try {
         execFileSync3("systemctl", ["--user", "daemon-reload"], { timeout: 1e4, stdio: "ignore" });
         execFileSync3("systemctl", ["--user", "enable", SYSTEMD_UNIT], { timeout: 1e4, stdio: "ignore" });
@@ -7194,14 +6947,14 @@ var SetupManager = class {
     const envPath = join8(dataDir, ".env");
     if (existsSync6(configPath)) {
       try {
-        const existing = JSON.parse(readFileSync4(configPath, "utf-8"));
+        const existing = JSON.parse(readFileSync3(configPath, "utf-8"));
         this.generateDockerFiles(existing);
         return { configPath, envPath, config: existing, isNew: false };
       } catch {
       }
     }
     if (!existsSync6(dataDir)) {
-      mkdirSync5(dataDir, { recursive: true });
+      mkdirSync4(dataDir, { recursive: true });
     }
     const masterKey = `mk_${randomBytes2(24).toString("hex")}`;
     const stalwartPassword = randomBytes2(16).toString("hex");
@@ -7217,7 +6970,7 @@ var SetupManager = class {
       api: { port: 3100, host: "127.0.0.1" },
       dataDir
     };
-    writeFileSync5(configPath, JSON.stringify(config, null, 2));
+    writeFileSync4(configPath, JSON.stringify(config, null, 2));
     chmodSync(configPath, 384);
     const envContent = `# Auto-generated by agenticmail setup
 STALWART_ADMIN_USER=admin
@@ -7233,7 +6986,7 @@ SMTP_PORT=587
 IMAP_HOST=localhost
 IMAP_PORT=143
 `;
-    writeFileSync5(envPath, envContent);
+    writeFileSync4(envPath, envContent);
     chmodSync(envPath, 384);
     this.generateDockerFiles(config);
     return { configPath, envPath, config, isNew: true };
@@ -7245,11 +6998,11 @@ IMAP_PORT=143
   generateDockerFiles(config) {
     const dataDir = config.dataDir || join8(homedir7(), ".agenticmail");
     if (!existsSync6(dataDir)) {
-      mkdirSync5(dataDir, { recursive: true });
+      mkdirSync4(dataDir, { recursive: true });
     }
     const password = config.stalwart?.adminPassword || "changeme";
     const composePath = join8(dataDir, "docker-compose.yml");
-    writeFileSync5(composePath, `services:
+    writeFileSync4(composePath, `services:
   stalwart:
     image: stalwartlabs/stalwart:latest
     container_name: agenticmail-stalwart
@@ -7272,7 +7025,7 @@ volumes:
   stalwart-data:
 `);
     const tomlPath = join8(dataDir, "stalwart.toml");
-    writeFileSync5(tomlPath, `# Stalwart Mail Server \u2014 AgenticMail Configuration
+    writeFileSync4(tomlPath, `# Stalwart Mail Server \u2014 AgenticMail Configuration
 
 [server]
 hostname = "localhost"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agenticmail/core",
-  "version": "0.5.23",
+  "version": "0.5.25",
   "description": "Core SDK for AgenticMail \u2014 email, SMS, and phone number access for AI agents",
   "type": "module",
   "main": "dist/index.js",