@agenticmail/core 0.4.0 → 0.5.0

package/dist/index.d.ts

@@ -1424,14 +1424,15 @@ declare class DependencyInstaller {
      */
     installDocker(): Promise<void>;
     /**
-     * Attempt to start the Docker daemon.
-     * On macOS: opens Docker Desktop app.
-     * On Linux: tries systemctl.
+     * Attempt to start the Docker daemon using multiple strategies.
+     * On macOS: tries Docker Desktop app, then docker CLI commands.
+     * On Linux: tries systemctl, then dockerd direct, then snap.
      */
     private startDockerDaemon;
     /**
-     * Wait for Docker daemon to be ready (up to 3 minutes).
-     * Docker Desktop can take 1-2+ minutes on first launch.
+     * Wait for Docker daemon to be ready, with automatic retry strategies.
+     * Tries multiple approaches to start Docker if the first one fails.
+     * Reports progress as a percentage (0-100).
      */
     private waitForDocker;
     /**

package/dist/index.js

@@ -5893,11 +5893,129 @@ var DependencyChecker = class {
 };
 
 // src/setup/installer.ts
-import { execFileSync as execFileSync2, execSync } from "child_process";
+import { execFileSync as execFileSync2, execSync, spawn as spawnChild } from "child_process";
 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";
+function runWithRollingOutput(command, args, opts = {}) {
+  const maxLines = opts.maxLines ?? 20;
+  const timeout = opts.timeout ?? 3e5;
+  return new Promise((resolve, reject) => {
+    const child = spawnChild(command, args, {
+      stdio: ["ignore", "pipe", "pipe"],
+      timeout
+    });
+    const lines = [];
+    let displayedCount = 0;
+    let fullOutput = "";
+    const processData = (data) => {
+      const text = data.toString();
+      fullOutput += text;
+      const newLines = text.split("\n");
+      for (const line of newLines) {
+        const trimmed = line.trimEnd();
+        if (!trimmed) continue;
+        lines.push(trimmed);
+        if (displayedCount > 0) {
+          const toClear = Math.min(displayedCount, maxLines);
+          process.stdout.write(`\x1B[${toClear}A`);
+          for (let i = 0; i < toClear; i++) {
+            process.stdout.write("\x1B[2K\n");
+          }
+          process.stdout.write(`\x1B[${toClear}A`);
+        }
+        const visible = lines.slice(-maxLines);
+        for (const vLine of visible) {
+          process.stdout.write(`  \x1B[90m${vLine.slice(0, 100)}\x1B[0m
+`);
+        }
+        displayedCount = visible.length;
+      }
+    };
+    child.stdout?.on("data", processData);
+    child.stderr?.on("data", processData);
+    child.on("close", (code) => {
+      if (displayedCount > 0) {
+        process.stdout.write(`\x1B[${displayedCount}A`);
+        for (let i = 0; i < displayedCount; i++) {
+          process.stdout.write("\x1B[2K\n");
+        }
+        process.stdout.write(`\x1B[${displayedCount}A`);
+      }
+      resolve({ exitCode: code ?? 1, fullOutput });
+    });
+    child.on("error", (err) => {
+      if (displayedCount > 0) {
+        process.stdout.write(`\x1B[${displayedCount}A`);
+        for (let i = 0; i < displayedCount; i++) {
+          process.stdout.write("\x1B[2K\n");
+        }
+        process.stdout.write(`\x1B[${displayedCount}A`);
+      }
+      reject(err);
+    });
+  });
+}
+function runShellWithRollingOutput(cmd, opts = {}) {
+  const maxLines = opts.maxLines ?? 20;
+  const timeout = opts.timeout ?? 3e5;
+  return new Promise((resolve, reject) => {
+    const child = spawnChild("sh", ["-c", cmd], {
+      stdio: ["ignore", "pipe", "pipe"],
+      timeout
+    });
+    const lines = [];
+    let displayedCount = 0;
+    let fullOutput = "";
+    const processData = (data) => {
+      const text = data.toString();
+      fullOutput += text;
+      const newLines = text.split("\n");
+      for (const line of newLines) {
+        const trimmed = line.trimEnd();
+        if (!trimmed) continue;
+        lines.push(trimmed);
+        if (displayedCount > 0) {
+          const toClear = Math.min(displayedCount, maxLines);
+          process.stdout.write(`\x1B[${toClear}A`);
+          for (let i = 0; i < toClear; i++) {
+            process.stdout.write("\x1B[2K\n");
+          }
+          process.stdout.write(`\x1B[${toClear}A`);
+        }
+        const visible = lines.slice(-maxLines);
+        for (const vLine of visible) {
+          process.stdout.write(`  \x1B[90m${vLine.slice(0, 100)}\x1B[0m
+`);
+        }
+        displayedCount = visible.length;
+      }
+    };
+    child.stdout?.on("data", processData);
+    child.stderr?.on("data", processData);
+    child.on("close", (code) => {
+      if (displayedCount > 0) {
+        process.stdout.write(`\x1B[${displayedCount}A`);
+        for (let i = 0; i < displayedCount; i++) {
+          process.stdout.write("\x1B[2K\n");
+        }
+        process.stdout.write(`\x1B[${displayedCount}A`);
+      }
+      resolve({ exitCode: code ?? 1, fullOutput });
+    });
+    child.on("error", (err) => {
+      if (displayedCount > 0) {
+        process.stdout.write(`\x1B[${displayedCount}A`);
+        for (let i = 0; i < displayedCount; i++) {
+          process.stdout.write("\x1B[2K\n");
+        }
+        process.stdout.write(`\x1B[${displayedCount}A`);
+      }
+      reject(err);
+    });
+  });
+}
 var DependencyInstaller = class {
   onProgress;
   constructor(onProgress) {
@@ -5935,14 +6053,20 @@ var DependencyInstaller = class {
       } catch {
         throw new Error("Homebrew is required to install Docker on macOS. Install it from https://brew.sh then try again.");
       }
-      execFileSync2("brew", ["install", "--cask", "docker"], { timeout: 3e5, stdio: "inherit" });
+      const brewResult = await runWithRollingOutput("brew", ["install", "--cask", "docker"], { timeout: 3e5 });
+      if (brewResult.exitCode !== 0) {
+        throw new Error("Failed to install Docker via Homebrew. Try: brew install --cask docker");
+      }
       this.onProgress("Docker installed. Starting Docker Desktop...");
       this.startDockerDaemon();
       await this.waitForDocker();
     } else if (os === "linux") {
       this.onProgress("Installing Docker...");
       try {
-        execSync("curl -fsSL https://get.docker.com | sh", { timeout: 3e5, stdio: "inherit" });
+        const result = await runShellWithRollingOutput("curl -fsSL https://get.docker.com | sh", { timeout: 3e5 });
+        if (result.exitCode !== 0) {
+          throw new Error("Install script failed");
+        }
       } catch {
         throw new Error("Failed to install Docker. Install it manually: https://docs.docker.com/get-docker/");
       }
@@ -5952,48 +6076,123 @@ var DependencyInstaller = class {
     }
   }
   /**
-   * Attempt to start the Docker daemon.
-   * On macOS: opens Docker Desktop app.
-   * On Linux: tries systemctl.
+   * Attempt to start the Docker daemon using multiple strategies.
+   * On macOS: tries Docker Desktop app, then docker CLI commands.
+   * On Linux: tries systemctl, then dockerd direct, then snap.
    */
-  startDockerDaemon() {
+  startDockerDaemon(strategy) {
     const os = platform2();
     if (os === "darwin") {
-      try {
-        execFileSync2("open", ["-a", "Docker"], { timeout: 1e4, stdio: "ignore" });
-      } catch {
+      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 {
+          }
+          try {
+            execFileSync2("open", ["-a", "Docker"], { timeout: 1e4, stdio: "ignore" });
+          } catch {
+          }
+          break;
+        case "background":
+          try {
+            const appBin = "/Applications/Docker.app/Contents/MacOS/Docker";
+            if (existsSync4(appBin)) {
+              execSync(`"${appBin}" &`, { timeout: 5e3, stdio: "ignore", shell: "sh" });
+            }
+          } catch {
+          }
+          break;
+        default:
+          try {
+            execFileSync2("open", ["-a", "Docker"], { timeout: 1e4, stdio: "ignore" });
+          } catch {
+          }
       }
     } else if (os === "linux") {
-      try {
-        execFileSync2("sudo", ["systemctl", "start", "docker"], { timeout: 15e3, stdio: "ignore" });
-      } catch {
+      switch (strategy) {
+        case "snap":
+          try {
+            execFileSync2("sudo", ["snap", "start", "docker"], { timeout: 15e3, stdio: "ignore" });
+          } catch {
+          }
+          break;
+        case "service":
+          try {
+            execFileSync2("sudo", ["service", "docker", "start"], { timeout: 15e3, stdio: "ignore" });
+          } catch {
+          }
+          break;
+        default:
+          try {
+            execFileSync2("sudo", ["systemctl", "start", "docker"], { timeout: 15e3, stdio: "ignore" });
+          } catch {
+          }
       }
     }
   }
   /**
-   * Wait for Docker daemon to be ready (up to 3 minutes).
-   * Docker Desktop can take 1-2+ minutes on first launch.
+   * Wait for Docker daemon to be ready, with automatic retry strategies.
+   * Tries multiple approaches to start Docker if the first one fails.
+   * Reports progress as a percentage (0-100).
    */
   async waitForDocker() {
-    this.onProgress("Waiting for Docker to start (this can take a minute)...");
-    const maxWait = 18e4;
+    const os = platform2();
+    const strategies = os === "darwin" ? ["default", "cli", "reopen", "background"] : ["default", "service", "snap"];
+    const totalTime = 24e4;
+    const perStrategyTime = Math.floor(totalTime / strategies.length);
     const start = Date.now();
-    let attempts = 0;
-    while (Date.now() - start < maxWait) {
+    let strategyIdx = 0;
+    this.onProgress("__progress__:0:Starting Docker...");
+    while (Date.now() - start < totalTime) {
       try {
         execFileSync2("docker", ["info"], { timeout: 5e3, stdio: "ignore" });
+        this.onProgress("__progress__:100:Docker is ready!");
         return;
       } catch {
       }
-      attempts++;
-      if (attempts % 5 === 0) {
-        const elapsed = Math.round((Date.now() - start) / 1e3);
-        this.onProgress(`Still waiting for Docker to start (${elapsed}s)...`);
+      const elapsed = Date.now() - start;
+      const pct = Math.min(95, Math.round(elapsed / totalTime * 100));
+      const currentStrategyElapsed = elapsed - strategyIdx * perStrategyTime;
+      if (currentStrategyElapsed >= perStrategyTime && strategyIdx < strategies.length - 1) {
+        strategyIdx++;
+        const strategy = strategies[strategyIdx];
+        const msgs = {
+          cli: "Trying Docker CLI...",
+          reopen: "Restarting Docker Desktop...",
+          background: "Trying direct launch...",
+          service: "Trying service command...",
+          snap: "Trying snap..."
+        };
+        this.onProgress(`__progress__:${pct}:${msgs[strategy] || "Trying another approach..."}`);
+        this.startDockerDaemon(strategy);
+      } else {
+        const msgs = [
+          "Starting Docker...",
+          "Waiting for Docker engine...",
+          "Docker is 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]}`);
       }
       await new Promise((r) => setTimeout(r, 3e3));
     }
     throw new Error(
-      "Docker daemon did not start in time. Open Docker Desktop manually, wait for it to finish loading, then run this again."
+      "DOCKER_MANUAL_START"
     );
   }
   /**
@@ -6010,14 +6209,17 @@ var DependencyInstaller = class {
       this.startDockerDaemon();
       await this.waitForDocker();
     }
-    this.onProgress("Starting Stalwart mail server...");
-    execFileSync2("docker", ["compose", "-f", composePath, "up", "-d"], {
-      timeout: 12e4,
-      stdio: ["ignore", "pipe", "pipe"]
-    });
+    this.onProgress("__progress__:10:Pulling mail server image...");
+    const composeResult = await runWithRollingOutput("docker", ["compose", "-f", composePath, "up", "-d"], { timeout: 12e4 });
+    if (composeResult.exitCode !== 0) {
+      throw new Error("Failed to start mail server container. Check Docker is running.");
+    }
+    this.onProgress("__progress__:60:Waiting for mail server to start...");
     const maxWait = 3e4;
     const start = Date.now();
     while (Date.now() - start < maxWait) {
+      const pct = 60 + Math.round((Date.now() - start) / maxWait * 35);
+      this.onProgress(`__progress__:${Math.min(95, pct)}:Starting mail server...`);
       try {
         const output = execFileSync2(
           "docker",
@@ -6025,6 +6227,7 @@ var DependencyInstaller = class {
           { timeout: 5e3, stdio: ["ignore", "pipe", "ignore"] }
         ).toString().trim();
         if (output.toLowerCase().includes("up")) {
+          this.onProgress("__progress__:100:Mail server ready!");
           return;
         }
       } catch {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agenticmail/core",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Core SDK for AgenticMail — programmatic email for AI agents",
   "type": "module",
   "main": "dist/index.js",