@iloom/cli 0.11.1 → 0.13.0-beta.0

package/dist/chunk-QQULYI2S.js

@@ -0,0 +1,696 @@
+#!/usr/bin/env node
+import {
+  DockerManager
+} from "./chunk-AYLC633W.js";
+import {
+  ProcessManager
+} from "./chunk-H3T3EPF3.js";
+import {
+  detectPackageManager,
+  runScript
+} from "./chunk-VIQOQ463.js";
+import {
+  getPackageScripts
+} from "./chunk-K3QGG4O2.js";
+import {
+  logger,
+  restoreTerminalState
+} from "./chunk-VRPPI6GU.js";
+
+// src/lib/DevServerManager.ts
+import path from "path";
+
+// src/lib/DockerDevServerStrategy.ts
+import { execa } from "execa";
+import net from "net";
+function tcpProbe(port) {
+  return new Promise((resolve) => {
+    const socket = net.createConnection({ port, host: "127.0.0.1" });
+    socket.once("connect", () => {
+      socket.destroy();
+      resolve(true);
+    });
+    socket.once("error", () => {
+      socket.destroy();
+      resolve(false);
+    });
+  });
+}
+var DockerDevServerStrategy = class {
+  constructor(_config, utils) {
+    this.utils = utils;
+  }
+  /**
+   * Resolve the container port using 3-tier fallback:
+   *   1. config.containerPort (explicit)
+   *   2. inspectImagePorts(imageName) (from built image)
+   *   3. parseDockerfileExpose(dockerfilePath) (from Dockerfile)
+   *
+   * Throws a clear error if all three return null.
+   *
+   * @param config - Docker config (may override the constructor config)
+   * @param imageName - Name of the built Docker image
+   * @param dockerfilePath - Absolute path to the Dockerfile
+   */
+  async resolveContainerPort(config, imageName, dockerfilePath) {
+    if (config.containerPort !== void 0) {
+      return config.containerPort;
+    }
+    const inspectedPort = await this.utils.inspectImagePorts(imageName);
+    if (inspectedPort !== null) {
+      logger.debug(`Auto-detected container port ${inspectedPort} from Docker image inspect`);
+      return inspectedPort;
+    }
+    const exposedPort = await this.utils.parseDockerfileExpose(dockerfilePath);
+    if (exposedPort !== null) {
+      logger.debug(`Auto-detected container port ${exposedPort} from Dockerfile EXPOSE directive`);
+      return exposedPort;
+    }
+    throw new Error(
+      "Cannot determine container port. Set `devServer.docker.containerPort` in settings or add an `EXPOSE` directive to your Dockerfile."
+    );
+  }
+  /**
+   * Build a Docker image for the worktree.
+   * Build context is always the worktree root directory.
+   *
+   * @param worktreePath - Absolute path to the worktree (build context)
+   * @param config - Docker config with Dockerfile path and build args
+   */
+  async buildImage(worktreePath, config) {
+    const imageName = this.utils.buildImageName(config.identifier ?? worktreePath);
+    const dockerfilePath = config.dockerFile ?? "./Dockerfile";
+    const args = ["build", "-t", imageName, "-f", dockerfilePath];
+    if (config.buildArgs) {
+      for (const [key, value] of Object.entries(config.buildArgs)) {
+        args.push("--build-arg", `${key}=${value}`);
+      }
+    }
+    args.push(".");
+    logger.info(`Building Docker image "${imageName}" from ${dockerfilePath}...`);
+    try {
+      await execa("docker", args, {
+        cwd: worktreePath,
+        stdio: "inherit"
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      throw new Error(`Docker build failed for image "${imageName}": ${message}`);
+    }
+    logger.success(`Docker image "${imageName}" built successfully`);
+  }
+  /**
+   * Run a container in detached (background) mode.
+   * Force-removes any existing container with the same name first.
+   * Mounts the worktree at /app and adds an anonymous volume for node_modules.
+   * Forwards PORT and any envOverrides into the container.
+   *
+   * @param worktreePath - Absolute path to the worktree (mounted at /app)
+   * @param hostPort - Port on the host to map
+   * @param containerPort - Port inside the container
+   * @param config - Docker config with run args
+   * @param envOverrides - Additional environment variables to set in the container
+   * @returns The container name
+   */
+  async runContainerDetached(worktreePath, hostPort, containerPort, config, envOverrides) {
+    const nameId = config.identifier ?? worktreePath;
+    const imageName = this.utils.buildImageName(nameId);
+    const containerName = this.utils.buildContainerName(nameId);
+    await execa("docker", ["rm", "-f", containerName], { reject: false });
+    const args = [
+      "run",
+      "-d",
+      "--name",
+      containerName,
+      "-p",
+      `${hostPort}:${containerPort}`,
+      // Mount worktree at /app
+      "-v",
+      `${worktreePath}:/app`,
+      // Anonymous volume for node_modules to prevent host/container conflicts
+      "-v",
+      "/app/node_modules",
+      // Forward PORT as the container port so the app listens where Docker expects.
+      // The -p mapping handles host-to-container translation.
+      "-e",
+      `PORT=${containerPort}`
+    ];
+    if (envOverrides) {
+      for (const [key, value] of Object.entries(envOverrides)) {
+        args.push("-e", `${key}=${value}`);
+      }
+    }
+    if (config.runArgs) {
+      args.push(...config.runArgs);
+    }
+    args.push(imageName);
+    logger.info(`Starting Docker container "${containerName}" in background (http://localhost:${hostPort} \u2192 container:${containerPort})...`);
+    try {
+      await execa("docker", args);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      throw new Error(`Failed to start Docker container "${containerName}": ${message}`);
+    }
+    logger.success(`Docker container "${containerName}" started on port ${hostPort}`);
+    return containerName;
+  }
+  /**
+   * Run a container in foreground (blocking) mode.
+   * The container is automatically removed on exit (--rm flag).
+   * Traps SIGINT and SIGTERM and forwards them to the container via docker stop.
+   *
+   * @param worktreePath - Absolute path to the worktree (mounted at /app)
+   * @param hostPort - Port on the host to map
+   * @param containerPort - Port inside the container
+   * @param config - Docker config with run args
+   * @param opts - Additional options (redirectToStderr, onProcessStarted, envOverrides)
+   * @returns Object with optional pid (Docker containers don't expose host PID)
+   */
+  async runContainerForeground(worktreePath, hostPort, containerPort, config, opts = {}) {
+    const nameId = config.identifier ?? worktreePath;
+    const imageName = this.utils.buildImageName(nameId);
+    const containerName = this.utils.buildContainerName(nameId);
+    const { redirectToStderr, onProcessStarted, envOverrides } = opts;
+    await execa("docker", ["rm", "-f", containerName], { reject: false });
+    const args = [
+      "run",
+      "--rm",
+      "--name",
+      containerName,
+      "-p",
+      `${hostPort}:${containerPort}`,
+      // Mount worktree at /app
+      "-v",
+      `${worktreePath}:/app`,
+      // Anonymous volume for node_modules to prevent host/container conflicts
+      "-v",
+      "/app/node_modules",
+      // Forward PORT as the container port so the app listens where Docker expects.
+      // The -p mapping handles host-to-container translation.
+      "-e",
+      `PORT=${containerPort}`
+    ];
+    if (envOverrides) {
+      for (const [key, value] of Object.entries(envOverrides)) {
+        args.push("-e", `${key}=${value}`);
+      }
+    }
+    if (config.runArgs) {
+      args.push(...config.runArgs);
+    }
+    args.push(imageName);
+    logger.info(`Running Docker container "${containerName}" in foreground (http://localhost:${hostPort} \u2192 container:${containerPort})...`);
+    const stdio = redirectToStderr ? [process.stdin, process.stderr, process.stderr] : "inherit";
+    const forwardSignal = () => {
+      logger.debug(`Stopping container "${containerName}"`);
+      void execa("docker", ["stop", containerName], { reject: false });
+    };
+    const onSigint = () => forwardSignal();
+    const onSigterm = () => forwardSignal();
+    process.on("SIGINT", onSigint);
+    process.on("SIGTERM", onSigterm);
+    if (onProcessStarted) {
+      onProcessStarted(void 0);
+    }
+    try {
+      await execa("docker", args, { stdio });
+    } finally {
+      process.removeListener("SIGINT", onSigint);
+      process.removeListener("SIGTERM", onSigterm);
+      restoreTerminalState();
+    }
+    return {};
+  }
+  /**
+   * Stop and remove a container by name.
+   * Uses docker rm -f which handles both running and stopped containers atomically.
+   * Handles already-stopped containers gracefully (no error thrown).
+   *
+   * @param containerName - Name of the container to stop and remove
+   */
+  async stopContainer(containerName) {
+    logger.debug(`Stopping and removing container "${containerName}"...`);
+    await execa("docker", ["rm", "-f", containerName], { reject: false });
+    logger.debug(`Container "${containerName}" stopped and removed`);
+  }
+  /**
+   * Check if a named container is currently running.
+   * Uses exact name matching with anchored regex to avoid partial name matches.
+   *
+   * @param containerName - Name of the container to check
+   * @returns true if the container is running, false otherwise
+   */
+  async isContainerRunning(containerName) {
+    try {
+      const result = await execa("docker", [
+        "ps",
+        "--filter",
+        `name=^${containerName}$`,
+        "--format",
+        "{{.Names}}"
+      ], { reject: false });
+      return result.exitCode === 0 && result.stdout.trim() === containerName;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Wait for the dev server to be ready by probing the TCP port.
+   * Uses net.createConnection instead of lsof-based detection since Docker port
+   * forwarding shows com.docker.backend as the listening process (not the dev server).
+   * Exits early if the container has stopped (crash detection).
+   *
+   * @param port - Host port to probe
+   * @param timeout - Maximum time to wait in milliseconds
+   * @param interval - Interval between probes in milliseconds
+   * @param containerName - Optional container name to monitor for early exit
+   * @returns true if the port accepts connections within the timeout, false otherwise
+   */
+  async waitForReady(port, timeout, interval, containerName) {
+    const startTime = Date.now();
+    let attempts = 0;
+    while (Date.now() - startTime < timeout) {
+      attempts++;
+      if (containerName && attempts % 3 === 0) {
+        const stillRunning = await this.isContainerRunning(containerName);
+        if (!stillRunning) {
+          logger.warn(
+            `Docker container "${containerName}" exited before becoming ready (after ${attempts} attempts, ${Date.now() - startTime}ms)`
+          );
+          return false;
+        }
+      }
+      const isReady = await tcpProbe(port);
+      if (isReady) {
+        return true;
+      }
+      await new Promise((resolve) => globalThis.setTimeout(resolve, interval));
+    }
+    return false;
+  }
+};
+
+// src/lib/NativeDevServerStrategy.ts
+import { execa as execa2 } from "execa";
+import { setTimeout } from "timers/promises";
+
+// src/utils/dev-server.ts
+async function buildDevServerCommand(workspacePath) {
+  const packageManager = await detectPackageManager(workspacePath);
+  let devCommand;
+  switch (packageManager) {
+    case "pnpm":
+      devCommand = "pnpm dev";
+      break;
+    case "npm":
+      devCommand = "npm run dev";
+      break;
+    case "yarn":
+      devCommand = "yarn dev";
+      break;
+    default:
+      logger.warn(`Unknown or unsupported package manager: ${packageManager}, defaulting to npm`);
+      devCommand = "npm run dev";
+  }
+  logger.debug(`Dev server command: ${devCommand}`);
+  return devCommand;
+}
+
+// src/lib/NativeDevServerStrategy.ts
+var NativeDevServerStrategy = class {
+  constructor(processManager, startupTimeout, checkInterval) {
+    this.runningServers = /* @__PURE__ */ new Map();
+    this.processManager = processManager;
+    this.startupTimeout = startupTimeout;
+    this.checkInterval = checkInterval;
+  }
+  async isRunning(port) {
+    const process2 = await this.processManager.detectDevServer(port);
+    return process2 !== null;
+  }
+  async startBackground(worktreePath, port, envOverrides) {
+    const scripts = await getPackageScripts(worktreePath);
+    if (!scripts["dev"]) {
+      logger.warn('Skipping auto-start: no "dev" script found in package.json or package.iloom.json');
+      return;
+    }
+    const devCommand = await buildDevServerCommand(worktreePath);
+    logger.debug(`Starting dev server with command: ${devCommand}`);
+    const serverProcess = execa2("sh", ["-c", devCommand], {
+      cwd: worktreePath,
+      env: {
+        ...process.env,
+        ...envOverrides,
+        PORT: port.toString()
+      },
+      // Important: Don't inherit stdio - server runs in background
+      stdio: "ignore",
+      // Detach from parent process so it continues running
+      detached: true
+    });
+    this.runningServers.set(port, serverProcess);
+    serverProcess.on("exit", () => {
+      this.runningServers.delete(port);
+    });
+    serverProcess.unref();
+    logger.info(`Waiting for dev server to start on port ${port}...`);
+    const ready = await this.waitForReady(port, serverProcess);
+    if (!ready) {
+      throw new Error(
+        `Dev server failed to start within ${this.startupTimeout}ms timeout`
+      );
+    }
+    logger.success(`Dev server started successfully on port ${port}`);
+  }
+  async startForeground(worktreePath, port, opts) {
+    const { redirectToStderr = false, onProcessStarted, envOverrides } = opts;
+    logger.debug(`Starting dev server in foreground on port ${port}`);
+    if (redirectToStderr) {
+      const devCommand = await buildDevServerCommand(worktreePath);
+      logger.debug(`Starting dev server with command: ${devCommand}`);
+      const serverProcess = execa2("sh", ["-c", devCommand], {
+        cwd: worktreePath,
+        env: {
+          ...process.env,
+          ...envOverrides,
+          PORT: port.toString()
+        },
+        stdio: [process.stdin, process.stderr, process.stderr]
+      });
+      const processInfo = serverProcess.pid !== void 0 ? { pid: serverProcess.pid } : {};
+      if (onProcessStarted) {
+        onProcessStarted(processInfo.pid);
+      }
+      const onSigint = () => {
+      };
+      process.on("SIGINT", onSigint);
+      try {
+        await serverProcess;
+      } catch (error) {
+        const execaError = error;
+        if (execaError.signal !== "SIGINT") {
+          throw error;
+        }
+      } finally {
+        process.removeListener("SIGINT", onSigint);
+        restoreTerminalState();
+      }
+      return processInfo;
+    }
+    return await runScript("dev", worktreePath, [], {
+      env: {
+        ...envOverrides,
+        PORT: port.toString()
+      },
+      foreground: true,
+      ...onProcessStarted && { onStart: onProcessStarted },
+      noCi: true
+      // Dev servers should not have CI=true
+    });
+  }
+  async stop(port) {
+    const serverProcess = this.runningServers.get(port);
+    if (!serverProcess) {
+      return false;
+    }
+    try {
+      if (serverProcess.pid) {
+        process.kill(-serverProcess.pid, "SIGTERM");
+      } else {
+        serverProcess.kill();
+      }
+      this.runningServers.delete(port);
+      return true;
+    } catch (error) {
+      logger.warn(
+        `Failed to kill server process on port ${port}: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+      return false;
+    }
+  }
+  /**
+   * Stop all tracked server processes. Called during cleanup.
+   */
+  async stopAll() {
+    for (const [port] of this.runningServers.entries()) {
+      await this.stop(port);
+    }
+  }
+  /**
+   * Wait for server to be ready by polling the port.
+   * Exits early if the spawned process has already exited (crash detection).
+   * Public so DevServerManager can reuse it for Docker mode readiness checks.
+   *
+   * @param port - Port to poll
+   * @param processRef - Optional spawned process to monitor for early exit
+   */
+  async waitForReady(port, processRef) {
+    const startTime = Date.now();
+    let attempts = 0;
+    while (Date.now() - startTime < this.startupTimeout) {
+      attempts++;
+      if (processRef && processRef.exitCode != null) {
+        logger.warn(
+          `Dev server process exited with code ${processRef.exitCode} before becoming ready (after ${attempts} attempts, ${Date.now() - startTime}ms)`
+        );
+        return false;
+      }
+      const processInfo = await this.processManager.detectDevServer(port);
+      if (processInfo) {
+        logger.debug(
+          `Server detected on port ${port} after ${attempts} attempts (${Date.now() - startTime}ms)`
+        );
+        return true;
+      }
+      await setTimeout(this.checkInterval);
+    }
+    logger.warn(
+      `Server did not start on port ${port} after ${this.startupTimeout}ms (${attempts} attempts)`
+    );
+    return false;
+  }
+};
+
+// src/lib/DevServerManager.ts
+var DEFAULT_STARTUP_TIMEOUT = 18e4;
+var dockerUtils = {
+  parseDockerfileExpose: (filePath) => DockerManager.parseExposeFromDockerfile(filePath),
+  inspectImagePorts: (imageName) => DockerManager.inspectImagePorts(imageName),
+  buildContainerName: (id) => DockerManager.buildContainerName(id),
+  buildImageName: (id) => DockerManager.buildImageName(id),
+  assertDockerAvailable: () => DockerManager.assertAvailable()
+};
+function getStartupTimeout() {
+  const envTimeout = process.env.ILOOM_DEV_SERVER_TIMEOUT;
+  if (envTimeout) {
+    const parsed = parseInt(envTimeout, 10);
+    if (!isNaN(parsed) && parsed > 0) {
+      return parsed;
+    }
+  }
+  return DEFAULT_STARTUP_TIMEOUT;
+}
+function toStrategyConfig(config) {
+  return {
+    dockerFile: config.dockerFile,
+    containerPort: config.containerPort,
+    buildArgs: config.dockerBuildArgs,
+    runArgs: config.dockerRunArgs,
+    identifier: config.identifier
+  };
+}
+var DevServerManager = class {
+  constructor(processManager, options = {}) {
+    this.runningDockerContainers = /* @__PURE__ */ new Map();
+    this.processManager = processManager ?? new ProcessManager();
+    this.options = {
+      startupTimeout: options.startupTimeout ?? getStartupTimeout(),
+      checkInterval: options.checkInterval ?? 1e3
+    };
+    this.nativeStrategy = new NativeDevServerStrategy(
+      this.processManager,
+      this.options.startupTimeout,
+      this.options.checkInterval
+    );
+  }
+  /**
+   * Create a DockerDevServerStrategy for the given Docker config.
+   * The strategy encapsulates all Docker container lifecycle operations.
+   */
+  createDockerStrategy(dockerConfig) {
+    return new DockerDevServerStrategy(toStrategyConfig(dockerConfig), dockerUtils);
+  }
+  /**
+   * Ensure dev server is running on the specified port.
+   * If not running, start it and wait for it to be ready.
+   *
+   * @param worktreePath - Path to the worktree
+   * @param port - Port the server should run on
+   * @param dockerConfig - Optional Docker configuration for container-based server
+   * @returns true if server is ready, false if startup failed/timed out
+   */
+  async ensureServerRunning(worktreePath, port, dockerConfig) {
+    logger.debug(`Checking if dev server is running on port ${port}...`);
+    if (dockerConfig) {
+      const strategy = this.createDockerStrategy(dockerConfig);
+      const containerName = dockerUtils.buildContainerName(dockerConfig.identifier);
+      const isRunning = await strategy.isContainerRunning(containerName);
+      if (isRunning) {
+        logger.debug(`Docker container "${containerName}" already running on port ${port}`);
+        return true;
+      }
+      logger.info(`Docker dev server not running on port ${port}, starting...`);
+      try {
+        await this.startDockerServer(worktreePath, port, dockerConfig, strategy);
+        return true;
+      } catch (error) {
+        logger.error(
+          `Failed to start Docker dev server: ${error instanceof Error ? error.message : "Unknown error"}`
+        );
+        return false;
+      }
+    }
+    const existingProcess = await this.processManager.detectDevServer(port);
+    if (existingProcess) {
+      logger.debug(
+        `Dev server already running on port ${port} (PID: ${existingProcess.pid})`
+      );
+      return true;
+    }
+    logger.info(`Dev server not running on port ${port}, starting...`);
+    try {
+      await this.nativeStrategy.startBackground(worktreePath, port);
+      return true;
+    } catch (error) {
+      logger.error(
+        `Failed to start dev server: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+      return false;
+    }
+  }
+  /**
+   * Start dev server in Docker container (background) and wait for it to be ready.
+   * Builds the image, resolves the container port, starts the container detached,
+   * and polls the host port for readiness.
+   */
+  async startDockerServer(worktreePath, port, dockerConfig, strategy) {
+    const strategyConfig = toStrategyConfig(dockerConfig);
+    const imageName = dockerUtils.buildImageName(dockerConfig.identifier);
+    const dockerfilePath = path.resolve(worktreePath, dockerConfig.dockerFile);
+    await strategy.buildImage(worktreePath, strategyConfig);
+    const containerPort = await strategy.resolveContainerPort(
+      strategyConfig,
+      imageName,
+      dockerfilePath
+    );
+    const containerName = await strategy.runContainerDetached(
+      worktreePath,
+      port,
+      containerPort,
+      strategyConfig
+    );
+    this.runningDockerContainers.set(port, containerName);
+    logger.info(`Waiting for Docker dev server to start on port ${port}...`);
+    const ready = await strategy.waitForReady(
+      port,
+      this.options.startupTimeout,
+      this.options.checkInterval,
+      containerName
+    );
+    if (!ready) {
+      await strategy.stopContainer(containerName);
+      this.runningDockerContainers.delete(port);
+      throw new Error(
+        `Docker dev server failed to start within ${this.options.startupTimeout}ms timeout`
+      );
+    }
+    logger.success(`Docker dev server started successfully on port ${port}`);
+  }
+  /**
+   * Check if a dev server is running on the specified port
+   *
+   * @param port - Port to check
+   * @param dockerConfig - Optional Docker configuration; when provided, checks container status
+   * @returns true if server is running, false otherwise
+   */
+  async isServerRunning(port, dockerConfig) {
+    if (dockerConfig) {
+      const strategy = this.createDockerStrategy(dockerConfig);
+      const containerName = dockerUtils.buildContainerName(dockerConfig.identifier);
+      return strategy.isContainerRunning(containerName);
+    }
+    const existingProcess = await this.processManager.detectDevServer(port);
+    return existingProcess !== null;
+  }
+  /**
+   * Run dev server in foreground mode (blocking).
+   * This method blocks until the server is stopped (e.g., via Ctrl+C).
+   *
+   * @param worktreePath - Path to the worktree
+   * @param port - Port the server should run on
+   * @param redirectToStderr - If true, redirect stdout/stderr to stderr (useful for JSON output)
+   * @param onProcessStarted - Callback called immediately after process starts with PID
+   * @returns Process information including PID
+   */
+  async runServerForeground(worktreePath, port, redirectToStderr = false, onProcessStarted, envOverrides, dockerConfig) {
+    if (dockerConfig) {
+      logger.debug(`Starting Docker dev server in foreground on port ${port}`);
+      const strategy = this.createDockerStrategy(dockerConfig);
+      const strategyConfig = toStrategyConfig(dockerConfig);
+      const imageName = dockerUtils.buildImageName(dockerConfig.identifier);
+      const containerName = dockerUtils.buildContainerName(dockerConfig.identifier);
+      const dockerfilePath = path.resolve(worktreePath, dockerConfig.dockerFile);
+      await strategy.buildImage(worktreePath, strategyConfig);
+      const containerPort = await strategy.resolveContainerPort(
+        strategyConfig,
+        imageName,
+        dockerfilePath
+      );
+      if (onProcessStarted) {
+        onProcessStarted(void 0);
+      }
+      this.runningDockerContainers.set(port, containerName);
+      try {
+        await strategy.runContainerForeground(
+          worktreePath,
+          port,
+          containerPort,
+          strategyConfig,
+          { redirectToStderr, envOverrides }
+        );
+      } finally {
+        this.runningDockerContainers.delete(port);
+      }
+      return {};
+    }
+    return this.nativeStrategy.startForeground(worktreePath, port, {
+      redirectToStderr,
+      ...onProcessStarted !== void 0 && { onProcessStarted },
+      ...envOverrides !== void 0 && { envOverrides }
+    });
+  }
+  /**
+   * Clean up all running server processes and Docker containers.
+   * This should be called when the manager is being disposed.
+   */
+  async cleanup() {
+    await this.nativeStrategy.stopAll();
+    for (const [port, containerName] of this.runningDockerContainers.entries()) {
+      try {
+        logger.debug(`Cleaning up Docker container "${containerName}" on port ${port}`);
+        const strategy = new DockerDevServerStrategy({}, dockerUtils);
+        await strategy.stopContainer(containerName);
+      } catch (error) {
+        logger.warn(
+          `Failed to stop Docker container "${containerName}" on port ${port}: ${error instanceof Error ? error.message : "Unknown error"}`
+        );
+      }
+    }
+    this.runningDockerContainers.clear();
+  }
+};
+
+export {
+  DevServerManager
+};
+//# sourceMappingURL=chunk-QQULYI2S.js.map