ensure-running 1.0.0

package/dist/index.cjs

@@ -0,0 +1,1184 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/services/docker/utils/Exec.ts
+async function exec(command, args = []) {
+  return new Promise((resolve, reject) => {
+    (0, import_node_child_process2.execFile)(
+      command,
+      args,
+      {
+        encoding: "utf8",
+        windowsHide: true
+      },
+      (err, stdout, stderr) => {
+        if (err) {
+          reject(err);
+          return;
+        }
+        resolve({
+          stdout: String(stdout ?? ""),
+          stderr: String(stderr ?? "")
+        });
+      }
+    );
+  });
+}
+async function execShell(shellCommand) {
+  const shell = process.platform === "win32" ? "cmd.exe" : "/bin/sh";
+  const shellFlag = process.platform === "win32" ? "/c" : "-c";
+  return exec(shell, [shellFlag, shellCommand]);
+}
+var import_node_child_process2;
+var init_Exec = __esm({
+  "src/services/docker/utils/Exec.ts"() {
+    "use strict";
+    import_node_child_process2 = require("child_process");
+  }
+});
+
+// src/services/docker/utils/Spawn.ts
+function spawn2(command, args = [], options = {}) {
+  return (0, import_node_child_process3.spawn)(command, args, {
+    detached: options.detached ?? false,
+    stdio: options.stdio ?? "ignore",
+    windowsHide: options.windowsHide ?? true
+  });
+}
+function spawnDetached(command, args = []) {
+  const child = spawn2(command, args, {
+    detached: true,
+    stdio: "ignore"
+  });
+  child.unref();
+  return child;
+}
+var import_node_child_process3;
+var init_Spawn = __esm({
+  "src/services/docker/utils/Spawn.ts"() {
+    "use strict";
+    import_node_child_process3 = require("child_process");
+  }
+});
+
+// src/services/docker/utils/Sleep.ts
+function sleep(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+var init_Sleep = __esm({
+  "src/services/docker/utils/Sleep.ts"() {
+    "use strict";
+  }
+});
+
+// src/services/docker/utils/Timeout.ts
+async function withTimeout(promise, timeoutMs, message = "Operation timed out") {
+  let timer;
+  const timeoutPromise = new Promise((_, reject) => {
+    timer = setTimeout(() => {
+      reject(new Error(message));
+    }, timeoutMs);
+  });
+  try {
+    return await Promise.race([promise, timeoutPromise]);
+  } finally {
+    if (timer !== void 0) {
+      clearTimeout(timer);
+    }
+  }
+}
+var init_Timeout = __esm({
+  "src/services/docker/utils/Timeout.ts"() {
+    "use strict";
+  }
+});
+
+// src/services/docker/utils/Which.ts
+async function which(command) {
+  try {
+    if (process.platform === "win32") {
+      const result = await exec("where.exe", [command]);
+      const firstLine = result.stdout.split(/\r?\n/).find((line) => line.trim().length > 0);
+      return firstLine?.trim();
+    }
+    try {
+      const result = await exec("which", [command]);
+      const path3 = result.stdout.trim();
+      return path3.length > 0 ? path3 : void 0;
+    } catch {
+      const result = await execShell(`command -v ${command}`);
+      const path3 = result.stdout.trim();
+      return path3.length > 0 ? path3 : void 0;
+    }
+  } catch {
+    return void 0;
+  }
+}
+async function commandExists(command) {
+  const path3 = await which(command);
+  return path3 !== void 0;
+}
+var init_Which = __esm({
+  "src/services/docker/utils/Which.ts"() {
+    "use strict";
+    init_Exec();
+  }
+});
+
+// src/services/docker/utils/Poll.ts
+async function poll(predicate, options) {
+  const deadline = Date.now() + options.timeout;
+  while (Date.now() < deadline) {
+    if (await predicate()) {
+      return true;
+    }
+    const remaining = deadline - Date.now();
+    if (remaining <= 0) {
+      break;
+    }
+    await sleep(Math.min(options.interval, remaining));
+  }
+  return false;
+}
+var init_Poll = __esm({
+  "src/services/docker/utils/Poll.ts"() {
+    "use strict";
+    init_Sleep();
+  }
+});
+
+// src/services/docker/utils/Retry.ts
+async function retry(fn, options) {
+  let lastError;
+  for (let attempt = 1; attempt <= options.attempts; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastError = err;
+      if (attempt < options.attempts) {
+        await sleep(options.delayMs);
+      }
+    }
+  }
+  throw lastError;
+}
+var init_Retry = __esm({
+  "src/services/docker/utils/Retry.ts"() {
+    "use strict";
+    init_Sleep();
+  }
+});
+
+// src/services/docker/utils/index.ts
+var utils_exports = {};
+__export(utils_exports, {
+  commandExists: () => commandExists,
+  exec: () => exec,
+  execShell: () => execShell,
+  poll: () => poll,
+  retry: () => retry,
+  sleep: () => sleep,
+  spawn: () => spawn2,
+  spawnDetached: () => spawnDetached,
+  which: () => which,
+  withTimeout: () => withTimeout
+});
+var init_utils = __esm({
+  "src/services/docker/utils/index.ts"() {
+    "use strict";
+    init_Exec();
+    init_Spawn();
+    init_Sleep();
+    init_Timeout();
+    init_Which();
+    init_Poll();
+    init_Retry();
+  }
+});
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  CliMode: () => CliMode,
+  CommandSeparator: () => CommandSeparator,
+  CommandSeparatorError: () => CommandSeparatorError,
+  CoreServiceRegistry: () => ServiceRegistry,
+  DefaultEnsureDockerOptions: () => DefaultEnsureDockerOptions,
+  DockerError: () => DockerError,
+  DockerErrorCode: () => DockerErrorCode,
+  DockerNotInstalledError: () => DockerNotInstalledError,
+  DockerNotRunningError: () => DockerNotRunningError,
+  DockerServiceMode: () => DockerServiceMode,
+  DockerStartError: () => DockerStartError,
+  DockerTimeoutError: () => DockerTimeoutError,
+  EnsureRunningError: () => EnsureRunningError,
+  EnsureServiceId: () => EnsureServiceId,
+  MissingCommandError: () => MissingCommandError,
+  assertEnsureService: () => assertEnsureService,
+  createBuiltInServiceRegistry: () => createBuiltInServiceRegistry,
+  createServiceRegistry: () => createServiceRegistry,
+  defineEnsureService: () => defineEnsureService,
+  detectDocker: () => detectDocker,
+  dockerService: () => dockerService,
+  ensure: () => ensure,
+  ensureDocker: () => ensureDocker,
+  ensureDockerRunning: () => ensureDockerRunning,
+  ensureRunning: () => ensureRunning,
+  findCustomServicesDir: () => findCustomServicesDir,
+  isDockerRunning: () => isDockerRunning,
+  loadCustomServices: () => loadCustomServices,
+  normalizeArgv: () => normalizeArgv,
+  parseDockerServiceArgs: () => parseDockerServiceArgs,
+  parseInvocation: () => parseInvocation,
+  printCliHelp: () => printCliHelp,
+  printDockerServiceHelp: () => printDockerServiceHelp,
+  readPackageVersion: () => readPackageVersion,
+  runCli: () => runCli,
+  runCommand: () => runCommand,
+  runDockerService: () => runDockerService,
+  runEnsureRunning: () => runEnsureRunning,
+  runInvocation: () => runInvocation
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/core/argv/Argv.ts
+function normalizeArgv(argv) {
+  const prefix = argv.slice(0, Math.min(argv.length, 4));
+  let scriptIndex = -1;
+  for (let index = 0; index < prefix.length; index++) {
+    const arg = prefix[index] ?? "";
+    if (arg.endsWith(".ts")) {
+      scriptIndex = index;
+    }
+  }
+  if (scriptIndex === -1) {
+    for (let index = 0; index < prefix.length; index++) {
+      const arg = prefix[index] ?? "";
+      if ((arg.endsWith(".mjs") || arg.endsWith(".cjs") || arg.endsWith(".js")) && (arg.includes("/") || arg.includes("\\"))) {
+        scriptIndex = index;
+      }
+    }
+  }
+  if (scriptIndex >= 0) {
+    return argv.slice(scriptIndex + 1);
+  }
+  if (argv.length >= 2 && (argv[0].includes("node") || argv[0].endsWith("node.exe"))) {
+    return argv.slice(2);
+  }
+  return [...argv];
+}
+
+// src/core/service/DefineEnsureService.ts
+function defineEnsureService(service) {
+  return service;
+}
+
+// src/core/registry/ServiceRegistry.ts
+var ServiceRegistry = class {
+  services = /* @__PURE__ */ new Map();
+  /**
+   * Registers a service by id and optional aliases.
+   */
+  register(service) {
+    this.services.set(service.id, service);
+    for (const alias of service.aliases ?? []) {
+      this.services.set(alias, service);
+    }
+  }
+  /**
+   * Resolves a service by id or alias.
+   */
+  resolve(name) {
+    return this.services.get(name);
+  }
+  /**
+   * Returns registered services without alias duplicates.
+   */
+  list() {
+    const seen = /* @__PURE__ */ new Set();
+    for (const service of this.services.values()) {
+      seen.add(service);
+    }
+    return [...seen];
+  }
+};
+
+// src/core/runner/Runner.ts
+var import_node_child_process = require("child_process");
+var CommandSeparator = "--";
+var CommandSeparatorError = class extends Error {
+  constructor(token) {
+    super(
+      `Unexpected argument "${token}". Use "${CommandSeparator}" before the command (e.g. er docker postgres ${CommandSeparator} vite dev).`
+    );
+    this.name = "CommandSeparatorError";
+  }
+};
+var MissingCommandError = class extends Error {
+  constructor() {
+    super(`Command separator "${CommandSeparator}" must be followed by a command.`);
+    this.name = "MissingCommandError";
+  }
+};
+function parseInvocation(argv, registry) {
+  let remaining = normalizeArgv(argv);
+  const services = [];
+  while (remaining.length > 0) {
+    const service = registry.resolve(remaining[0] ?? "");
+    if (service === void 0) {
+      break;
+    }
+    remaining = remaining.slice(1);
+    const parsed = service.parseArgs(remaining);
+    services.push({
+      service,
+      options: parsed.options
+    });
+    remaining = parsed.remaining;
+  }
+  let command;
+  if (remaining.length === 0) {
+    command = void 0;
+  } else if (remaining[0] === CommandSeparator) {
+    command = remaining.slice(1);
+    if (command.length === 0) {
+      throw new MissingCommandError();
+    }
+  } else {
+    throw new CommandSeparatorError(remaining[0] ?? "");
+  }
+  return {
+    services,
+    command
+  };
+}
+async function runInvocation(invocation) {
+  for (const entry of invocation.services) {
+    const exitCode = await entry.service.run(entry.options);
+    if (exitCode !== 0) {
+      return exitCode;
+    }
+  }
+  if (invocation.command === void 0) {
+    return 0;
+  }
+  return runCommand(invocation.command);
+}
+function runCommand(command) {
+  const [executable, ...args] = command;
+  if (executable === void 0) {
+    return Promise.resolve(1);
+  }
+  return new Promise((resolve) => {
+    const child = (0, import_node_child_process.spawn)(executable, args, {
+      stdio: "inherit",
+      shell: process.platform === "win32"
+    });
+    child.on("error", () => {
+      resolve(1);
+    });
+    child.on("close", (code) => {
+      resolve(code ?? 1);
+    });
+  });
+}
+
+// src/services/docker/commands/Commands.ts
+init_utils();
+var DockerCliVersionPattern = /Docker version\s+([^\s,]+)/i;
+function parseDockerCliVersion(stdout) {
+  const match = stdout.match(DockerCliVersionPattern);
+  return match?.[1];
+}
+async function resolveDockerExecutable() {
+  return which("docker");
+}
+async function isDockerDaemonReachable(executable = "docker") {
+  try {
+    await exec(executable, ["info"]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function runDockerVersion(executable = "docker") {
+  let clientVersion;
+  try {
+    const result = await exec(executable, ["--version"]);
+    clientVersion = parseDockerCliVersion(result.stdout);
+  } catch {
+    return { serverReachable: false };
+  }
+  if (clientVersion === void 0) {
+    return { serverReachable: false };
+  }
+  let serverReachable = false;
+  try {
+    const serverResult = await exec(executable, [
+      "version",
+      "--format",
+      "{{.Server.Version}}"
+    ]);
+    serverReachable = serverResult.stdout.trim().length > 0;
+  } catch {
+    serverReachable = false;
+  }
+  return { clientVersion, serverReachable };
+}
+async function validateDockerInstallation(executable) {
+  try {
+    const result = await exec(executable, ["--version"]);
+    return parseDockerCliVersion(result.stdout) !== void 0;
+  } catch {
+    return false;
+  }
+}
+async function runDockerDesktopStart(executable = "docker") {
+  await exec(executable, ["desktop", "start"]);
+}
+
+// src/services/docker/detect/Detect.ts
+async function detectDocker() {
+  const executable = await resolveDockerExecutable();
+  if (executable === void 0) {
+    return {
+      installed: false,
+      running: false
+    };
+  }
+  const installed = await validateDockerInstallation(executable);
+  if (!installed) {
+    return {
+      installed: false,
+      running: false,
+      executable
+    };
+  }
+  const running = await isDockerDaemonReachable(executable);
+  let version;
+  if (installed) {
+    const versionInfo = await runDockerVersion(executable);
+    version = versionInfo.clientVersion;
+  }
+  return {
+    installed: true,
+    running,
+    version,
+    executable
+  };
+}
+
+// src/services/docker/errors/Errors.ts
+var DockerErrorCode = /* @__PURE__ */ ((DockerErrorCode2) => {
+  DockerErrorCode2["NOT_INSTALLED"] = "NOT_INSTALLED";
+  DockerErrorCode2["NOT_RUNNING"] = "NOT_RUNNING";
+  DockerErrorCode2["START_FAILED"] = "START_FAILED";
+  DockerErrorCode2["TIMEOUT"] = "TIMEOUT";
+  return DockerErrorCode2;
+})(DockerErrorCode || {});
+var DockerError = class extends Error {
+  code;
+  constructor(message, code, options) {
+    super(message, options);
+    this.name = "DockerError";
+    this.code = code;
+  }
+};
+var DockerNotInstalledError = class extends DockerError {
+  constructor(message = "Docker is not installed. Install Docker and ensure the CLI is on your PATH.") {
+    super(message, "NOT_INSTALLED" /* NOT_INSTALLED */);
+    this.name = "DockerNotInstalledError";
+  }
+};
+var DockerNotRunningError = class extends DockerError {
+  constructor(message = "Docker is installed but the daemon is not running. Start Docker or pass autoStart: true.") {
+    super(message, "NOT_RUNNING" /* NOT_RUNNING */);
+    this.name = "DockerNotRunningError";
+  }
+};
+var DockerStartError = class extends DockerError {
+  constructor(message = "Failed to start Docker. Start Docker manually and try again.", options) {
+    super(message, "START_FAILED" /* START_FAILED */, options);
+    this.name = "DockerStartError";
+  }
+};
+var DockerTimeoutError = class extends DockerError {
+  constructor(timeoutMs) {
+    const seconds = Math.round(timeoutMs / 1e3);
+    super(
+      `Timed out after ${seconds}s waiting for the Docker daemon to become ready.`,
+      "TIMEOUT" /* TIMEOUT */
+    );
+    this.name = "DockerTimeoutError";
+  }
+};
+
+// src/services/docker/logger/Logger.ts
+var noop = () => void 0;
+function resolveLogger(logger) {
+  return {
+    info: logger?.info ?? noop,
+    warn: logger?.warn ?? noop,
+    debug: logger?.debug ?? noop
+  };
+}
+
+// src/services/docker/platforms/Platforms.ts
+var import_promises = require("fs/promises");
+var import_node_path = __toESM(require("path"), 1);
+
+// src/services/docker/process/Process.ts
+init_utils();
+function startDockerdDetached() {
+  spawnDetached("dockerd", []);
+}
+async function openMacApplication(appName) {
+  const { exec: exec2 } = await Promise.resolve().then(() => (init_utils(), utils_exports));
+  await exec2("open", ["-a", appName]);
+}
+function launchWindowsExecutable(executablePath) {
+  spawnDetached(executablePath, []);
+}
+
+// src/services/docker/platforms/Platforms.ts
+init_utils();
+async function startDockerLinux(logger, _dockerExecutable = "docker") {
+  const errors = [];
+  if (await commandExists("systemctl")) {
+    try {
+      logger.debug("Attempting: systemctl start docker");
+      await exec("systemctl", ["start", "docker"]);
+      logger.info("Started Docker via systemctl.");
+      return;
+    } catch (err) {
+      errors.push(err instanceof Error ? err : new Error(String(err)));
+      logger.warn("systemctl start docker failed.");
+    }
+  }
+  if (await commandExists("service")) {
+    try {
+      logger.debug("Attempting: service docker start");
+      await exec("service", ["docker", "start"]);
+      logger.info("Started Docker via service.");
+      return;
+    } catch (err) {
+      errors.push(err instanceof Error ? err : new Error(String(err)));
+      logger.warn("service docker start failed.");
+    }
+  }
+  if (await commandExists("dockerd")) {
+    try {
+      logger.debug("Attempting: dockerd (detached)");
+      startDockerdDetached();
+      logger.info("Started dockerd in the background.");
+      return;
+    } catch (err) {
+      errors.push(err instanceof Error ? err : new Error(String(err)));
+      logger.warn("dockerd detached start failed.");
+    }
+  }
+  const aggregate = new Error(
+    "No supported Docker start method found on Linux (systemctl, service, or dockerd)."
+  );
+  if (errors.length > 0) {
+    aggregate.cause = errors[errors.length - 1];
+  }
+  throw aggregate;
+}
+function getWindowsDockerDesktopCandidates() {
+  const programFiles = process.env.ProgramFiles ?? "C:\\Program Files";
+  const programFilesX86 = process.env["ProgramFiles(x86)"] ?? "C:\\Program Files (x86)";
+  const localAppData = process.env.LOCALAPPDATA ?? "";
+  const programData = process.env.ProgramData ?? "";
+  const candidates = [
+    import_node_path.default.join(programFiles, "Docker", "Docker", "Docker Desktop.exe"),
+    import_node_path.default.join(programFilesX86, "Docker", "Docker", "Docker Desktop.exe"),
+    localAppData ? import_node_path.default.join(localAppData, "Docker", "Docker Desktop.exe") : void 0,
+    programData ? import_node_path.default.join(programData, "Docker", "Docker Desktop.exe") : void 0
+  ];
+  return candidates.filter((candidate) => candidate !== void 0);
+}
+async function findWindowsDockerDesktop() {
+  for (const candidate of getWindowsDockerDesktopCandidates()) {
+    try {
+      await (0, import_promises.access)(candidate);
+      return candidate;
+    } catch {
+      continue;
+    }
+  }
+  const pathHit = await Promise.resolve().then(() => (init_utils(), utils_exports)).then((utils) => utils.which("Docker Desktop.exe"));
+  return pathHit;
+}
+async function startDockerWindows(logger, dockerExecutable = "docker") {
+  try {
+    logger.debug("Attempting: docker desktop start");
+    await runDockerDesktopStart(dockerExecutable);
+    logger.info("Started Docker Desktop via CLI.");
+    return;
+  } catch (err) {
+    logger.warn("docker desktop start failed, searching for Docker Desktop.exe.");
+    const desktopPath = await findWindowsDockerDesktop();
+    if (desktopPath === void 0) {
+      throw err instanceof Error ? err : new Error(String(err));
+    }
+    logger.debug(`Launching: ${desktopPath}`);
+    launchWindowsExecutable(desktopPath);
+    logger.info("Launched Docker Desktop executable.");
+  }
+}
+async function startDockerMacOS(logger, dockerExecutable = "docker") {
+  try {
+    logger.debug("Attempting: docker desktop start");
+    await runDockerDesktopStart(dockerExecutable);
+    logger.info("Started Docker Desktop via CLI.");
+    return;
+  } catch {
+    logger.warn("docker desktop start failed, trying open -a Docker.");
+    await openMacApplication("Docker");
+    logger.info("Opened Docker.app.");
+  }
+}
+async function startDocker(logger, dockerExecutable = "docker") {
+  if (process.platform === "win32") {
+    await startDockerWindows(logger, dockerExecutable);
+    return;
+  }
+  if (process.platform === "darwin") {
+    await startDockerMacOS(logger, dockerExecutable);
+    return;
+  }
+  await startDockerLinux(logger, dockerExecutable);
+}
+
+// src/services/docker/types/Types.ts
+var DefaultEnsureDockerOptions = {
+  timeout: 12e4,
+  interval: 1e3,
+  autoStart: true
+};
+
+// src/services/docker/wait/Wait.ts
+init_utils();
+async function waitForDocker(options) {
+  const executable = options.executable ?? "docker";
+  const logger = options.logger;
+  logger?.debug("Waiting for Docker daemon...");
+  const ready = await poll(async () => isDockerDaemonReachable(executable), {
+    timeout: options.timeout,
+    interval: options.interval
+  });
+  if (!ready) {
+    throw new DockerTimeoutError(options.timeout);
+  }
+  logger?.info("Docker is ready.");
+}
+
+// src/services/docker/ensure/Ensure.ts
+async function isDockerRunning() {
+  try {
+    const result = await detectDocker();
+    return result.installed && result.running;
+  } catch {
+    return false;
+  }
+}
+async function ensureDockerRunning(options) {
+  const timeout = options?.timeout ?? DefaultEnsureDockerOptions.timeout;
+  const interval = options?.interval ?? DefaultEnsureDockerOptions.interval;
+  const autoStart = options?.autoStart ?? DefaultEnsureDockerOptions.autoStart;
+  const logger = resolveLogger(options?.logger);
+  logger.info("Checking Docker installation...");
+  const detection = await detectDocker();
+  if (!detection.installed) {
+    throw new DockerNotInstalledError();
+  }
+  logger.info("Docker found.");
+  if (detection.running) {
+    logger.info("Docker daemon is already running.");
+    return;
+  }
+  logger.warn("Docker daemon not running.");
+  if (!autoStart) {
+    throw new DockerNotRunningError();
+  }
+  logger.info("Attempting to start Docker...");
+  const executable = detection.executable ?? "docker";
+  try {
+    await startDocker(logger, executable);
+  } catch (err) {
+    throw new DockerStartError(void 0, {
+      cause: err instanceof Error ? err : new Error(String(err))
+    });
+  }
+  await waitForDocker({
+    timeout,
+    interval,
+    executable,
+    logger
+  });
+}
+
+// src/services/docker/service/DockerService.ts
+var DockerServiceMode = /* @__PURE__ */ ((DockerServiceMode2) => {
+  DockerServiceMode2["ENSURE"] = "ENSURE";
+  DockerServiceMode2["CHECK"] = "CHECK";
+  return DockerServiceMode2;
+})(DockerServiceMode || {});
+function parseDockerServiceArgs(argv) {
+  const remaining = [...argv];
+  let mode = "ENSURE" /* ENSURE */;
+  let timeout = DefaultEnsureDockerOptions.timeout;
+  let interval = DefaultEnsureDockerOptions.interval;
+  let autoStart = DefaultEnsureDockerOptions.autoStart;
+  let quiet = false;
+  while (remaining.length > 0) {
+    const arg = remaining[0];
+    if (arg === "--check") {
+      mode = "CHECK" /* CHECK */;
+      remaining.shift();
+      continue;
+    }
+    if (arg === "-q" || arg === "--quiet") {
+      quiet = true;
+      remaining.shift();
+      continue;
+    }
+    if (arg === "--no-auto-start" || arg === "--no-start") {
+      autoStart = false;
+      remaining.shift();
+      continue;
+    }
+    if (arg === "--timeout") {
+      remaining.shift();
+      timeout = parsePositiveInteger(remaining.shift(), "--timeout");
+      continue;
+    }
+    if (arg === "--interval") {
+      remaining.shift();
+      interval = parsePositiveInteger(remaining.shift(), "--interval");
+      continue;
+    }
+    if (arg === CommandSeparator) {
+      break;
+    }
+    if (arg.startsWith("-")) {
+      throw new Error(`Unknown docker option: ${arg}`);
+    }
+    break;
+  }
+  return {
+    options: {
+      mode,
+      timeout,
+      interval,
+      autoStart,
+      quiet
+    },
+    remaining
+  };
+}
+async function runDockerService(options) {
+  const logger = options.quiet ? void 0 : createConsoleLogger();
+  try {
+    if (options.mode === "CHECK" /* CHECK */) {
+      const running = await isDockerRunning();
+      if (!running && !options.quiet) {
+        console.error("Docker is not running.");
+      }
+      return running ? 0 : 1;
+    }
+    await ensureDockerRunning({
+      timeout: options.timeout,
+      interval: options.interval,
+      autoStart: options.autoStart,
+      logger
+    });
+    return 0;
+  } catch (err) {
+    if (!options.quiet) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.error(message);
+    }
+    return 1;
+  }
+}
+function printDockerServiceHelp() {
+  console.log(`docker [options]
+
+Ensure Docker is installed, started, and ready.
+
+Options:
+  --check              Exit 0 when the daemon is reachable; do not auto-start
+  --timeout <ms>       Max wait for daemon readiness (default: ${DefaultEnsureDockerOptions.timeout})
+  --interval <ms>      Poll interval between checks (default: ${DefaultEnsureDockerOptions.interval})
+  --no-auto-start      Fail when the daemon is down instead of starting Docker
+  -q, --quiet          Suppress progress output`);
+}
+var dockerService = defineEnsureService({
+  id: "docker",
+  aliases: ["d"],
+  parseArgs: parseDockerServiceArgs,
+  run: runDockerService,
+  printHelp: printDockerServiceHelp
+});
+function parsePositiveInteger(value, flag) {
+  if (value === void 0) {
+    throw new Error(`Missing value for ${flag}`);
+  }
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed <= 0) {
+    throw new Error(`${flag} expects a positive integer, received: ${value}`);
+  }
+  return parsed;
+}
+function createConsoleLogger() {
+  return {
+    info: (message) => {
+      console.log(message);
+    },
+    warn: (message) => {
+      console.warn(message);
+    },
+    debug: (message) => {
+      console.debug(message);
+    }
+  };
+}
+
+// src/services/LoadCustomServices.ts
+var import_node_fs = require("fs");
+var import_promises2 = require("fs/promises");
+var import_node_path2 = __toESM(require("path"), 1);
+var import_node_url = require("url");
+
+// src/services/AssertEnsureService.ts
+function assertEnsureService(value, source) {
+  if (value === null || typeof value !== "object") {
+    throw new Error(`${source}: export default must be an object`);
+  }
+  const candidate = value;
+  if (typeof candidate.id !== "string" || candidate.id.length === 0) {
+    throw new Error(`${source}: export default must define a non-empty string "id"`);
+  }
+  if (typeof candidate.parseArgs !== "function") {
+    throw new Error(`${source}: export default must define "parseArgs(argv)"`);
+  }
+  if (typeof candidate.run !== "function") {
+    throw new Error(`${source}: export default must define "run(options)"`);
+  }
+  if (candidate.printHelp !== void 0 && typeof candidate.printHelp !== "function") {
+    throw new Error(`${source}: "printHelp" must be a function when provided`);
+  }
+  return value;
+}
+
+// src/services/LoadCustomServices.ts
+var import_meta = {};
+var SERVICE_FILE_PATTERN = /\.(?:[cm]?js|mjs|ts)$/i;
+function findCustomServicesDir(startDir) {
+  let current = import_node_path2.default.resolve(startDir);
+  while (true) {
+    const candidate = import_node_path2.default.join(current, ".er", "services");
+    if ((0, import_node_fs.existsSync)(candidate)) {
+      return candidate;
+    }
+    const parent = import_node_path2.default.dirname(current);
+    if (parent === current) {
+      return void 0;
+    }
+    current = parent;
+  }
+}
+async function loadCustomServices(registry, cwd = process.cwd()) {
+  const dir = findCustomServicesDir(cwd);
+  if (dir === void 0) {
+    return;
+  }
+  const entries = await (0, import_promises2.readdir)(dir, { withFileTypes: true });
+  const files = entries.filter((entry) => entry.isFile() && SERVICE_FILE_PATTERN.test(entry.name)).map((entry) => import_node_path2.default.join(dir, entry.name)).sort();
+  for (const filePath of files) {
+    const service = await importCustomService(filePath);
+    registry.register(service);
+  }
+}
+async function importCustomService(filePath) {
+  const ext = import_node_path2.default.extname(filePath).toLowerCase();
+  let loaded;
+  if (ext === ".ts" || ext === ".mts" || ext === ".cts") {
+    const { createJiti } = await import("jiti");
+    const jiti = createJiti(import_meta.url, { interopDefault: true });
+    loaded = jiti(filePath);
+  } else {
+    const module2 = await import((0, import_node_url.pathToFileURL)(filePath).href);
+    loaded = module2.default ?? module2;
+  }
+  return assertEnsureService(loaded, filePath);
+}
+
+// src/services/CreateServiceRegistry.ts
+async function createServiceRegistry(cwd = process.cwd()) {
+  const registry = createBuiltInServiceRegistry();
+  await loadCustomServices(registry, cwd);
+  return registry;
+}
+function createBuiltInServiceRegistry() {
+  const registry = new ServiceRegistry();
+  registry.register(dockerService);
+  return registry;
+}
+
+// src/api/EnsureRunning.ts
+var EnsureRunningError = class extends Error {
+  serviceId;
+  exitCode;
+  constructor(serviceId, exitCode, message = `Service "${serviceId}" failed with exit code ${exitCode}.`) {
+    super(message);
+    this.name = "EnsureRunningError";
+    this.serviceId = serviceId;
+    this.exitCode = exitCode;
+  }
+};
+var EnsureServiceId = /* @__PURE__ */ ((EnsureServiceId2) => {
+  EnsureServiceId2["DOCKER"] = "docker";
+  return EnsureServiceId2;
+})(EnsureServiceId || {});
+async function ensureRunning(input) {
+  const request = normalizeRequest(input);
+  const registry = request.registry ?? await createServiceRegistry(request.cwd);
+  for (const serviceInput of request.services) {
+    const entry = resolveServiceInput(serviceInput, registry);
+    const exitCode = await entry.service.run(entry.options);
+    if (exitCode !== 0) {
+      throw new EnsureRunningError(entry.service.id, exitCode);
+    }
+  }
+}
+async function runEnsureRunning(request) {
+  await ensureRunning(request);
+  if (request.command === void 0 || request.command.length === 0) {
+    return 0;
+  }
+  return runCommand(request.command);
+}
+async function ensureDocker(options) {
+  if (options?.check === true) {
+    const running = await isDockerRunning();
+    if (!running) {
+      throw new DockerNotRunningError();
+    }
+    return;
+  }
+  await ensureDockerRunning({
+    timeout: options?.timeout,
+    interval: options?.interval,
+    autoStart: options?.autoStart,
+    logger: options?.quiet === true ? void 0 : options?.logger
+  });
+}
+var ensure = {
+  docker: ensureDocker,
+  running: ensureRunning
+};
+function normalizeRequest(input) {
+  if (Array.isArray(input)) {
+    return {
+      services: input
+    };
+  }
+  return input;
+}
+function resolveServiceInput(input, registry) {
+  if (typeof input === "string") {
+    const service2 = registry.resolve(input);
+    if (service2 === void 0) {
+      throw new EnsureRunningError(input, 1, `Unknown service: ${input}`);
+    }
+    return {
+      service: service2,
+      options: defaultServiceOptions(service2.id)
+    };
+  }
+  const service = registry.resolve(input.service);
+  if (service === void 0) {
+    throw new EnsureRunningError(String(input.service), 1, `Unknown service: ${input.service}`);
+  }
+  return {
+    service,
+    options: toServiceOptions(service.id, input.options)
+  };
+}
+function defaultServiceOptions(serviceId) {
+  if (serviceId === "docker" /* DOCKER */) {
+    return toDockerServiceOptions();
+  }
+  return {};
+}
+function toServiceOptions(serviceId, options) {
+  if (serviceId === "docker" /* DOCKER */) {
+    return toDockerServiceOptions(options);
+  }
+  return options ?? {};
+}
+function toDockerServiceOptions(options) {
+  return {
+    mode: options?.check === true ? "CHECK" /* CHECK */ : "ENSURE" /* ENSURE */,
+    timeout: options?.timeout ?? DefaultEnsureDockerOptions.timeout,
+    interval: options?.interval ?? DefaultEnsureDockerOptions.interval,
+    autoStart: options?.autoStart ?? DefaultEnsureDockerOptions.autoStart,
+    quiet: options?.quiet ?? false
+  };
+}
+
+// src/cli/Cli.ts
+var import_node_fs2 = require("fs");
+var import_node_url2 = require("url");
+var import_meta2 = {};
+var CliMode = /* @__PURE__ */ ((CliMode2) => {
+  CliMode2["HELP"] = "HELP";
+  CliMode2["VERSION"] = "VERSION";
+  CliMode2["RUN"] = "RUN";
+  return CliMode2;
+})(CliMode || {});
+function readPackageVersion() {
+  const packageJsonPath = (0, import_node_url2.fileURLToPath)(new URL("../../package.json", import_meta2.url));
+  const packageJson = JSON.parse((0, import_node_fs2.readFileSync)(packageJsonPath, "utf8"));
+  return packageJson.version;
+}
+function printCliHelp(registry) {
+  const serviceLines = registry.list().map((service) => `  ${service.id.padEnd(10)} ${getServiceSummary(service)}`).join("\n");
+  console.log(`Usage: ensure-running | er [service [flags...]]... [--] [command...]
+
+Ensure local services are ready, then optionally run a command.
+
+Services:
+${serviceLines}
+
+Custom services:
+  Place files in .er/services/ with export default defineEnsureService({ ... })
+
+Examples:
+  er docker
+  er docker --check
+  er docker postgres -- vite dev
+  er docker --timeout 60000 -- npm test
+
+Use "--" to separate services from the command you want to run.
+
+Global options:
+  -h, --help       Show this help message
+  -v, --version    Print CLI version
+  service --help   Show service-specific help`);
+}
+async function runCli(argv, registry) {
+  const resolvedRegistry = registry ?? await createServiceRegistry();
+  const normalized = normalizeArgv(argv);
+  if (normalized.length === 0 || normalized[0] === "-h" || normalized[0] === "--help") {
+    printCliHelp(resolvedRegistry);
+    return 0;
+  }
+  if (normalized[0] === "-v" || normalized[0] === "--version") {
+    console.log(readPackageVersion());
+    return 0;
+  }
+  if (normalized.length >= 2 && (normalized[1] === "--help" || normalized[1] === "-h")) {
+    const service = resolvedRegistry.resolve(normalized[0] ?? "");
+    if (service?.printHelp !== void 0) {
+      service.printHelp();
+      return 0;
+    }
+  }
+  try {
+    const invocation = parseInvocation(normalized, resolvedRegistry);
+    if (invocation.services.length === 0 && invocation.command === void 0) {
+      printCliHelp(resolvedRegistry);
+      return 1;
+    }
+    return await runInvocation(invocation);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(message);
+    printCliHelp(resolvedRegistry);
+    return 1;
+  }
+}
+function getServiceSummary(service) {
+  if (service.id === "docker") {
+    return "Ensure Docker CLI is installed and the daemon is ready";
+  }
+  return "Ensure service is ready";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CliMode,
+  CommandSeparator,
+  CommandSeparatorError,
+  CoreServiceRegistry,
+  DefaultEnsureDockerOptions,
+  DockerError,
+  DockerErrorCode,
+  DockerNotInstalledError,
+  DockerNotRunningError,
+  DockerServiceMode,
+  DockerStartError,
+  DockerTimeoutError,
+  EnsureRunningError,
+  EnsureServiceId,
+  MissingCommandError,
+  assertEnsureService,
+  createBuiltInServiceRegistry,
+  createServiceRegistry,
+  defineEnsureService,
+  detectDocker,
+  dockerService,
+  ensure,
+  ensureDocker,
+  ensureDockerRunning,
+  ensureRunning,
+  findCustomServicesDir,
+  isDockerRunning,
+  loadCustomServices,
+  normalizeArgv,
+  parseDockerServiceArgs,
+  parseInvocation,
+  printCliHelp,
+  printDockerServiceHelp,
+  readPackageVersion,
+  runCli,
+  runCommand,
+  runDockerService,
+  runEnsureRunning,
+  runInvocation
+});
+//# sourceMappingURL=index.cjs.map