ensure-running 1.0.0

package/dist/bin/ensure-running.js

@@ -0,0 +1,959 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 });
+};
+
+// src/services/docker/utils/Exec.ts
+import { execFile as nodeExecFile } from "child_process";
+async function exec(command, args = []) {
+  return new Promise((resolve, reject) => {
+    nodeExecFile(
+      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 init_Exec = __esm({
+  "src/services/docker/utils/Exec.ts"() {
+    "use strict";
+  }
+});
+
+// src/services/docker/utils/Spawn.ts
+import { spawn as nodeSpawn } from "child_process";
+function spawn2(command, args = [], options = {}) {
+  return nodeSpawn(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 init_Spawn = __esm({
+  "src/services/docker/utils/Spawn.ts"() {
+    "use strict";
+  }
+});
+
+// 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/cli/Cli.ts
+import { readFileSync } from "fs";
+import { fileURLToPath } from "url";
+
+// 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
+import { spawn } from "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 = 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 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
+import { access } from "fs/promises";
+import path from "path";
+
+// 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 = [
+    path.join(programFiles, "Docker", "Docker", "Docker Desktop.exe"),
+    path.join(programFilesX86, "Docker", "Docker", "Docker Desktop.exe"),
+    localAppData ? path.join(localAppData, "Docker", "Docker Desktop.exe") : void 0,
+    programData ? path.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 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
+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
+import { existsSync } from "fs";
+import { readdir } from "fs/promises";
+import path2 from "path";
+import { pathToFileURL } from "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 SERVICE_FILE_PATTERN = /\.(?:[cm]?js|mjs|ts)$/i;
+function findCustomServicesDir(startDir) {
+  let current = path2.resolve(startDir);
+  while (true) {
+    const candidate = path2.join(current, ".er", "services");
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+    const parent = path2.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 readdir(dir, { withFileTypes: true });
+  const files = entries.filter((entry) => entry.isFile() && SERVICE_FILE_PATTERN.test(entry.name)).map((entry) => path2.join(dir, entry.name)).sort();
+  for (const filePath of files) {
+    const service = await importCustomService(filePath);
+    registry.register(service);
+  }
+}
+async function importCustomService(filePath) {
+  const ext = path2.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 module = await import(pathToFileURL(filePath).href);
+    loaded = module.default ?? module;
+  }
+  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/cli/Cli.ts
+function readPackageVersion() {
+  const packageJsonPath = fileURLToPath(new URL("../../package.json", import.meta.url));
+  const packageJson = JSON.parse(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";
+}
+
+// src/bin/ensure-running.ts
+runCli(process.argv).then((exitCode) => {
+  process.exit(exitCode);
+});
+//# sourceMappingURL=ensure-running.js.map