podkeeper 0.3.0

package/LICENSE

@@ -0,0 +1,7 @@
+Copyright 2024 Degu Labs, Inc
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,102 @@
+# PodKeeper
+
+> ⚠️ **Warning:** PodKeeper is currently in pre-1.0.0 release. Expect potential changes and experimental features that may not be fully stable yet.
+
+PodKeeper is a node.js open-source library for starting and stopping Docker containers in a way that ensures they won’t linger if the host program crashes or exits unexpectedly without properly stopping them.
+
+PodKeeper is written in TypeScript and comes bundled with TypeScript types.
+
+- [Getting Started](#getting-started)
+- [Bundled Services & API](#bundled-services--api)
+- [How It Works](#how-it-works)
+- [PodKeeper vs. TestContainers](#podkeeper-vs-testcontainers)
+
+## Getting Started
+
+1. Install podkeeper:
+
+    ```sh
+    npm i --save-dev podkeeper
+    ```
+
+1. Pull container you wish to launch beforehand:
+
+    ```sh
+    docker pull postgres:latest
+    ```
+
+1. Start / stop container programmatically:
+
+    ```ts
+    import { Postgres } from 'podkeeper';
+
+    const postgres = await Postgres.start();
+    // do something with container...
+    await postgres.stop();
+    ```
+
+## Bundled services & API
+
+PodKeeper comes bundled with the following pre-configured services:
+
+* MySQL:
+
+    ```ts
+    import { MySQL } from 'podkeeper';
+    ```
+
+* Postgres
+
+    ```ts
+    import { Postgres } from 'podkeeper';
+    ```
+
+* Minio
+
+    ```ts
+    import { Minio } from 'podkeeper';
+    ```
+
+If a popular service is missing, please do not hesitate to submit a pull request.
+Alternatively, you can launch a generic container service with the `GenericService` class:
+
+```ts
+import { GenericService } from 'podkeeper';
+
+cosnt service = await GenericService.start({
+  imageName: string,
+  ports: number[],
+  healthcheck?: {
+    test: string[],
+    intervalMs: number,
+    retries: number,
+    startPeriodMs: number,
+    timeoutMs: number,
+  },
+  command?: string[],
+  env?: { [key: string]: string | number | boolean | undefined };
+});
+```
+
+## How It Works
+
+Each Docker container has a primary process, known as the "entrypoint," which keeps the container running. For example, when you start a PostgreSQL container, it runs the `postgres` binary. When this binary exits, the container stops as well.
+
+PodKeeper wraps the entrypoint in a special binary called `deadmanswitch`, which not only starts the entrypoint but also launches a WebSocket server. The client that initiated the container must connect to this WebSocket server; otherwise, the container will self-terminate after 10 seconds.
+
+This setup creates a connection between the launched container and its owner. Whenever this WebSocket disconnects, the `deadmanswitch` program automatically stops the container.
+
+## PodKeeper vs. TestContainers
+
+Both PodKeeper and [TestContainers](https://testcontainers.com/) provide solutions for starting, stopping, and cleaning up Docker containers:
+
+- **TestContainers** uses a dedicated Docker container called "Ryuk" to manage cleanup.
+- **PodKeeper** relies on a [dead man's switch](https://en.wikipedia.org/wiki/Dead_man%27s_switch) mechanism for cleanup.
+
+While TestContainers is a mature, industry-proven tool, PodKeeper is an experimental alternative that explores a different approach.
+
+There are also some notable differences in API design philosophy:
+
+- **Process Behavior**: PodKeeper services prevent the Node.js process from exiting, while TestContainers services do not.
+- **Container Pulling**: PodKeeper does not implicitly pull containers, requiring them to be available beforehand, whereas TestContainers lazily pulls containers as needed when launching a service.
+- **Healthchecks**: The services that PodKeeper ships out-of-the-box are pre-configured to use proper healthchecks.

package/deadmanswitch/README.md

@@ -0,0 +1,34 @@
+# DeadManSwitch
+
+DeadManSwitch is a lightweight Go program that runs a specified command with arguments and simultaneously starts a WebSocket signaling server.
+
+## Program Behavior
+
+DeadManSwitch operates with the following behavior:
+
+1. If the launched command exits, DeadManSwitch exits as well.
+2. If no client connects to the WebSocket signaling server within `DEADMANSWITCH_TIMEOUT` seconds (default is 10 seconds), the process terminates.
+3. If a client connects but then disconnects, the process terminates.
+
+## Configuration
+
+You can configure DeadManSwitch using the following environment variables:
+
+- **`DEADMANSWITCH_TIMEOUT`**: Sets the timeout (in seconds) to wait for clients to connect to the WebSocket signaling server. Default is 10 seconds.
+- **`DEADMANSWITCH_PORT`**: Specifies the port to run the server on.
+- **`DEADMANSWITCH_SUFFIX`**: Defines a suffix for the WebSocket URL endpoint.
+
+## Usage Example
+
+The following command launches `sleep 100` and accepts WebSocket connections on `ws://localhost:54321/foobar`:
+
+```bash
+DEADMANSWITCH_TIMEOUT=10 \
+DEADMANSWITCH_PORT=54321 \
+DEADMANSWITCH_SUFFIX=foobar \
+deadmanswitch sleep 100
+```
+
+## Compilation
+
+To compile, run `./build.sh`

package/lib/dockerApi.js

@@ -0,0 +1,181 @@
+import http from "http";
+const DOCKER_API_VERSION = "1.41";
+async function listContainers() {
+  const containers = await getJSON("/containers/json") ?? [];
+  return containers.map((container) => ({
+    containerId: container.Id,
+    imageId: container.ImageID,
+    state: container.State,
+    // Note: container names are usually prefixed with '/'.
+    // See https://github.com/moby/moby/issues/6705
+    names: (container.Names ?? []).map((name) => name.startsWith("/") ? name.substring(1) : name),
+    portBindings: container.Ports?.map((portInfo) => ({
+      ip: portInfo.IP,
+      hostPort: portInfo.PublicPort,
+      containerPort: portInfo.PrivatePort
+    })) ?? [],
+    labels: container.Labels ?? {}
+  }));
+}
+async function isContainerHealthy(containerId) {
+  const container = await getJSON(`/containers/${containerId}/json`);
+  return container?.State?.Health?.Status === "healthy";
+}
+async function launchContainer(options) {
+  const ExposedPorts = {};
+  const PortBindings = {};
+  for (const port of options.ports ?? []) {
+    ExposedPorts[`${port.container}/tcp`] = {};
+    PortBindings[`${port.container}/tcp`] = [{ HostPort: port.host + "", HostIp: "127.0.0.1" }];
+  }
+  const container = await postJSON(`/containers/create` + (options.name ? "?name=" + options.name : ""), {
+    Cmd: options.command,
+    WorkingDir: options.workingDir,
+    Labels: options.labels ?? {},
+    AttachStdin: false,
+    AttachStdout: false,
+    AttachStderr: false,
+    Image: options.imageId,
+    ExposedPorts,
+    Entrypoint: options.entrypoint,
+    Healthcheck: options.healthcheck ? {
+      Test: options.healthcheck.test,
+      Interval: options.healthcheck.intervalMs * 1e6,
+      // must be in nano seconds
+      Timeout: options.healthcheck.timeoutMs * 1e6,
+      // must be in nano seconds
+      Retries: options.healthcheck.retries,
+      StartPeriod: options.healthcheck.startPeriodMs * 1e6
+      // must be in nano seconds
+    } : void 0,
+    Env: dockerProtocolEnv(options.env),
+    HostConfig: {
+      Binds: options.binds?.map((bind) => `${bind.hostPath}:${bind.containerPath}`),
+      Init: true,
+      AutoRemove: options.autoRemove,
+      ShmSize: 2 * 1024 * 1024 * 1024,
+      PortBindings
+    }
+  });
+  await postJSON(`/containers/${container.Id}/start`);
+  if (options.waitUntil)
+    await postJSON(`/containers/${container.Id}/wait?condition=${options.waitUntil}`);
+  return container.Id;
+}
+async function stopContainer(options) {
+  await Promise.all([
+    // Make sure to wait for the container to be removed.
+    postJSON(`/containers/${options.containerId}/wait?condition=${options.waitUntil ?? "not-running"}`),
+    postJSON(`/containers/${options.containerId}/kill`)
+  ]);
+}
+async function removeContainer(containerId) {
+  await Promise.all([
+    // Make sure to wait for the container to be removed.
+    postJSON(`/containers/${containerId}/wait?condition=removed`),
+    callDockerAPI("delete", `/containers/${containerId}`)
+  ]);
+}
+async function getContainerLogs(containerId) {
+  const rawLogs = await callDockerAPI("get", `/containers/${containerId}/logs?stdout=true&stderr=true`).catch((e) => "");
+  if (!rawLogs)
+    return [];
+  return rawLogs.split("\n").map((line) => {
+    if ([0, 1, 2].includes(line.charCodeAt(0)))
+      return line.substring(8);
+    return line;
+  });
+}
+function dockerProtocolEnv(env) {
+  const result = [];
+  for (const [key, value] of Object.entries(env ?? {}))
+    result.push(`${key}=${value}`);
+  return result;
+}
+async function commitContainer(options) {
+  await postJSON(`/commit?container=${options.containerId}&repo=${options.repo}&tag=${options.tag}`, {
+    Entrypoint: options.entrypoint,
+    WorkingDir: options.workingDir,
+    Env: dockerProtocolEnv(options.env)
+  });
+}
+async function inspectImage(imageId) {
+  return await getJSON(`/images/${imageId}/json`);
+}
+async function listImages() {
+  const rawImages = await getJSON("/images/json") ?? [];
+  return rawImages.map((rawImage) => ({
+    imageId: rawImage.Id,
+    names: rawImage.RepoTags ?? []
+  }));
+}
+async function removeImage(imageId) {
+  await callDockerAPI("delete", `/images/${imageId}`);
+}
+async function checkEngineRunning() {
+  try {
+    await callDockerAPI("get", "/info");
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+async function getJSON(url) {
+  const result = await callDockerAPI("get", url);
+  if (!result)
+    return result;
+  return JSON.parse(result);
+}
+async function postJSON(url, json = void 0) {
+  const result = await callDockerAPI("post", url, json ? JSON.stringify(json) : void 0);
+  if (!result)
+    return result;
+  return JSON.parse(result);
+}
+function callDockerAPI(method, url, body = void 0) {
+  const dockerSocket = process.platform === "win32" ? "\\\\.\\pipe\\docker_engine" : "/var/run/docker.sock";
+  return new Promise((resolve, reject) => {
+    const request = http.request({
+      socketPath: dockerSocket,
+      path: `/v${DOCKER_API_VERSION}${url}`,
+      timeout: 3e4,
+      method
+    }, (response) => {
+      let body2 = "";
+      response.on("data", function(chunk) {
+        body2 += chunk;
+      });
+      response.on("end", function() {
+        if (!response.statusCode || response.statusCode < 200 || response.statusCode >= 300)
+          reject(new Error(`${method} ${url} FAILED with statusCode ${response.statusCode} and body
+${body2}`));
+        else
+          resolve(body2);
+      });
+    });
+    request.on("error", function(e) {
+      reject(e);
+    });
+    if (body) {
+      request.setHeader("Content-Type", "application/json");
+      request.setHeader("Content-Length", body.length);
+      request.write(body);
+    } else {
+      request.setHeader("Content-Type", "text/plain");
+    }
+    request.end();
+  });
+}
+export {
+  checkEngineRunning,
+  commitContainer,
+  getContainerLogs,
+  inspectImage,
+  isContainerHealthy,
+  launchContainer,
+  listContainers,
+  listImages,
+  removeContainer,
+  removeImage,
+  stopContainer
+};

package/lib/genericService.js

@@ -0,0 +1,84 @@
+import { setTimeout } from "timers/promises";
+import { WebSocket } from "ws";
+import * as dockerApi from "./dockerApi.js";
+import path from "path";
+import url from "url";
+const __filename = url.fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+async function connectWebSocket(address, deadline) {
+  while (Date.now() < deadline) {
+    const socket = new WebSocket(address);
+    const result = await new Promise((resolve, reject) => {
+      socket.on("open", () => resolve(true));
+      socket.on("error", () => reject(false));
+    });
+    if (result)
+      return socket;
+    await setTimeout(100, void 0);
+  }
+  return void 0;
+}
+class GenericService {
+  constructor(_containerId, _bindings, _ws) {
+    this._containerId = _containerId;
+    this._bindings = _bindings;
+    this._ws = _ws;
+  }
+  static async start(options) {
+    const images = await dockerApi.listImages();
+    const image = images.find((image2) => image2.names.includes(options.imageName));
+    if (!image)
+      throw new Error(`ERROR: no image named "${options.imageName}" - run 'docker pull ${options.imageName}'`);
+    const metadata = await dockerApi.inspectImage(image.imageId);
+    const imageArch = metadata.Architecture;
+    const entrypoint = ["/deadmanswitch"];
+    const command = [metadata.Config.Entrypoint, options.command ?? metadata.Config.Cmd].flat();
+    const deadmanswitchName = imageArch === "arm64" ? "deadmanswitch_linux_aarch64" : "deadmanswitch_linux_x86_64";
+    const usedPorts = new Set(options.ports);
+    let switchPort = 54321;
+    while (usedPorts.has(switchPort))
+      ++switchPort;
+    const containerId = await dockerApi.launchContainer({
+      imageId: image.imageId,
+      autoRemove: true,
+      binds: [
+        { containerPath: "/deadmanswitch", hostPath: path.join(__dirname, "..", "deadmanswitch", "bin", deadmanswitchName) }
+      ],
+      ports: [
+        ...options.ports.map((port) => ({ container: port, host: 0 })),
+        { container: switchPort, host: 0 }
+      ],
+      entrypoint,
+      command,
+      healthcheck: options.healthcheck,
+      env: options.env
+    });
+    const deadline = Date.now() + 1e4;
+    const container = (await dockerApi.listContainers()).find((container2) => container2.containerId === containerId);
+    if (!container)
+      throw new Error("ERROR: failed to launch container!");
+    const switchBinding = container.portBindings.find((binding) => binding.containerPort === switchPort);
+    if (!switchBinding || !switchBinding.hostPort) {
+      await dockerApi.stopContainer({ containerId: container.containerId });
+      throw new Error("Failed to expose service to host");
+    }
+    while (!await dockerApi.isContainerHealthy(container.containerId))
+      await setTimeout(100, void 0);
+    const ws = await connectWebSocket(`ws://localhost:${switchBinding.hostPort}/`, deadline);
+    if (!ws)
+      throw new Error("Failed to connect to launched container");
+    const service = new GenericService(containerId, container.portBindings, ws);
+    return service;
+  }
+  mappedPort(containerPort) {
+    const binding = this._bindings.find((binding2) => binding2.containerPort === containerPort);
+    return binding?.hostPort;
+  }
+  async stop() {
+    this._ws.close();
+    await dockerApi.stopContainer({ containerId: this._containerId });
+  }
+}
+export {
+  GenericService
+};

package/lib/index.js

@@ -0,0 +1,8 @@
+import * as dockerApi from "./dockerApi.js";
+export * from "./genericService.js";
+export * from "./minio.js";
+export * from "./mysql.js";
+export * from "./postgres.js";
+export {
+  dockerApi
+};

package/lib/minio.js

@@ -0,0 +1,51 @@
+import ms from "ms";
+import { GenericService } from "./genericService.js";
+class Minio {
+  constructor(_service, _accessKeyId, _secretAccessKey) {
+    this._service = _service;
+    this._accessKeyId = _accessKeyId;
+    this._secretAccessKey = _secretAccessKey;
+  }
+  static async start({ accessKeyId = "root", secretAccessKey = "password" } = {}) {
+    const service = await GenericService.start({
+      imageName: "quay.io/minio/minio:latest",
+      ports: [9e3, 9090],
+      healthcheck: {
+        test: ["CMD", `mc`, `ready`, `local`],
+        intervalMs: ms("100ms"),
+        retries: 10,
+        startPeriodMs: ms("30s"),
+        timeoutMs: ms("5s")
+      },
+      env: {
+        "MINIO_ROOT_USER": accessKeyId,
+        "MINIO_ROOT_PASSWORD": secretAccessKey
+      },
+      command: [
+        "server",
+        "/data",
+        "--console-address",
+        ":9090"
+      ]
+    });
+    return new Minio(service, accessKeyId, secretAccessKey);
+  }
+  accessKeyId() {
+    return this._accessKeyId;
+  }
+  secretAccessKey() {
+    return this._secretAccessKey;
+  }
+  apiEndpoint() {
+    return "http://localhost:" + this._service.mappedPort(9e3);
+  }
+  webuiEndpoint() {
+    return "http://localhost:" + this._service.mappedPort(9090);
+  }
+  async stop() {
+    await this._service.stop();
+  }
+}
+export {
+  Minio
+};

package/lib/mysql.js

@@ -0,0 +1,49 @@
+import ms from "ms";
+import { GenericService } from "./genericService.js";
+const MYSQL_IMAGE_NAME = "mysql:latest";
+const MYSQL_PORT = 3306;
+class MySQL {
+  constructor(_service, _rootPassword, _db) {
+    this._service = _service;
+    this._rootPassword = _rootPassword;
+    this._db = _db;
+  }
+  static async start({ db = "mydatabase", rootPassword = "rootpassword" } = {}) {
+    const service = await GenericService.start({
+      imageName: "mysql:latest",
+      ports: [MYSQL_PORT],
+      healthcheck: {
+        test: ["CMD-SHELL", `mysqladmin ping --host 127.0.0.1 -u root --password=${rootPassword}`],
+        intervalMs: ms("100ms"),
+        retries: 10,
+        startPeriodMs: 0,
+        timeoutMs: ms("5s")
+      },
+      command: ["mysqld", "--innodb-force-recovery=0", "--skip-innodb-doublewrite"],
+      env: {
+        "MYSQL_ROOT_PASSWORD": rootPassword,
+        "MYSQL_DATABASE": db,
+        "MYSQL_INITDB_SKIP_TZINFO": true
+      }
+    });
+    return new MySQL(service, rootPassword, db);
+  }
+  databaseUrl() {
+    return `mysql://root:${this._rootPassword}@localhost:${this._service.mappedPort(MYSQL_PORT)}/${this._db}`;
+  }
+  connectOptions() {
+    return {
+      host: "localhost",
+      port: this._service.mappedPort(MYSQL_PORT),
+      database: this._db,
+      user: "root",
+      password: this._rootPassword
+    };
+  }
+  async stop() {
+    await this._service.stop();
+  }
+}
+export {
+  MySQL
+};

package/lib/postgres.js

@@ -0,0 +1,53 @@
+import ms from "ms";
+import { GenericService } from "./genericService.js";
+const IMAGE_NAME = "postgres:latest";
+const POSTGRES_PORT = 5432;
+class Postgres {
+  constructor(_service, _user, _password, _db) {
+    this._service = _service;
+    this._user = _user;
+    this._password = _password;
+    this._db = _db;
+  }
+  static async start({ user = "user", password = "password", db = "postgres" } = {}) {
+    const service = await GenericService.start({
+      imageName: "postgres:latest",
+      ports: [POSTGRES_PORT],
+      healthcheck: {
+        test: ["CMD-SHELL", "pg_isready"],
+        intervalMs: ms("1s"),
+        retries: 10,
+        startPeriodMs: 0,
+        timeoutMs: ms("5s")
+      },
+      env: {
+        "POSTGRES_USER": user,
+        "POSTGRES_PASSWORD": password,
+        "POSTGRES_DB": db,
+        // Duplicate env variables for the healthchecks.
+        "PGUSER": user,
+        "PGPASSWORD": password,
+        "PGDATABASE": db
+      }
+    });
+    return new Postgres(service, user, password, db);
+  }
+  databaseUrl() {
+    return `postgres://${this._user}:${this._password}@localhost:${this._service.mappedPort(POSTGRES_PORT)}/${this._db}`;
+  }
+  connectOptions() {
+    return {
+      host: "localhost",
+      port: this._service.mappedPort(POSTGRES_PORT),
+      database: this._db,
+      user: this._user,
+      password: this._password
+    };
+  }
+  async stop() {
+    await this._service.stop();
+  }
+}
+export {
+  Postgres
+};

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "podkeeper",
+  "type": "module",
+  "version": "0.3.0",
+  "description": "",
+  "exports": {
+    ".": {
+      "types": "./types/index.d.ts",
+      "import": "./lib/index.js",
+      "require": "./lib/index.js"
+    }
+  },
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/flakiness/podkeeper.git"
+  },
+  "homepage": "https://github.com/flakiness/podkeeper",
+  "keywords": [],
+  "author": "",
+  "license": "MIT",
+  "devDependencies": {
+    "@degulabs/build": "^0.0.1",
+    "@playwright/test": "^1.48.2",
+    "@types/ms": "^0.7.34",
+    "@types/node": "^22.8.5",
+    "@types/ws": "^8.5.12",
+    "esbuild": "^0.24.0",
+    "typescript": "^5.6.3"
+  },
+  "dependencies": {
+    "ms": "^2.1.3",
+    "ws": "^8.18.0"
+  }
+}

package/types/dockerApi.d.ts

@@ -0,0 +1,71 @@
+export interface DockerImage {
+    imageId: string;
+    names: string[];
+}
+export interface PortBinding {
+    ip: string;
+    hostPort: number;
+    containerPort: number;
+}
+export interface DockerContainer {
+    containerId: string;
+    labels: Record<string, string>;
+    imageId: string;
+    state: 'created' | 'restarting' | 'running' | 'removing' | 'paused' | 'exited' | 'dead';
+    names: string[];
+    portBindings: PortBinding[];
+}
+export declare function listContainers(): Promise<DockerContainer[]>;
+export declare function isContainerHealthy(containerId: string): Promise<boolean>;
+interface LaunchContainerOptions {
+    imageId: string;
+    autoRemove: boolean;
+    command?: string[];
+    entrypoint?: string[];
+    labels?: Record<string, string>;
+    ports?: {
+        container: number;
+        host: number;
+    }[];
+    name?: string;
+    healthcheck?: {
+        test: string[];
+        intervalMs: number;
+        timeoutMs: number;
+        retries: number;
+        startPeriodMs: number;
+    };
+    binds?: {
+        hostPath: string;
+        containerPath: string;
+    }[];
+    workingDir?: string;
+    waitUntil?: 'not-running' | 'next-exit' | 'removed';
+    env?: {
+        [key: string]: string | number | boolean | undefined;
+    };
+}
+export declare function launchContainer(options: LaunchContainerOptions): Promise<string>;
+interface StopContainerOptions {
+    containerId: string;
+    waitUntil?: 'not-running' | 'next-exit' | 'removed';
+}
+export declare function stopContainer(options: StopContainerOptions): Promise<void>;
+export declare function removeContainer(containerId: string): Promise<void>;
+export declare function getContainerLogs(containerId: string): Promise<string[]>;
+interface CommitContainerOptions {
+    containerId: string;
+    repo: string;
+    tag: string;
+    entrypoint?: string[];
+    workingDir?: string;
+    env?: {
+        [key: string]: string | number | boolean | undefined;
+    };
+}
+export declare function commitContainer(options: CommitContainerOptions): Promise<void>;
+export declare function inspectImage(imageId: string): Promise<any>;
+export declare function listImages(): Promise<DockerImage[]>;
+export declare function removeImage(imageId: string): Promise<void>;
+export declare function checkEngineRunning(): Promise<boolean>;
+export {};

package/types/genericService.d.ts

@@ -0,0 +1,25 @@
+import { WebSocket } from 'ws';
+import * as dockerApi from './dockerApi.js';
+export declare class GenericService {
+    private _containerId;
+    private _bindings;
+    private _ws;
+    static start(options: {
+        imageName: string;
+        ports: number[];
+        healthcheck?: {
+            test: string[];
+            intervalMs: number;
+            retries: number;
+            startPeriodMs: number;
+            timeoutMs: number;
+        };
+        command?: string[];
+        env?: {
+            [key: string]: string | number | boolean | undefined;
+        };
+    }): Promise<GenericService>;
+    constructor(_containerId: string, _bindings: dockerApi.PortBinding[], _ws: WebSocket);
+    mappedPort(containerPort: number): number | undefined;
+    stop(): Promise<void>;
+}

package/types/index.d.ts

@@ -0,0 +1,5 @@
+export * as dockerApi from './dockerApi.js';
+export * from './genericService.js';
+export * from './minio.js';
+export * from './mysql.js';
+export * from './postgres.js';

package/types/minio.d.ts

@@ -0,0 +1,16 @@
+import { GenericService } from './genericService.js';
+export declare class Minio {
+    private _service;
+    private _accessKeyId;
+    private _secretAccessKey;
+    static start({ accessKeyId, secretAccessKey }?: {
+        accessKeyId?: string | undefined;
+        secretAccessKey?: string | undefined;
+    }): Promise<Minio>;
+    constructor(_service: GenericService, _accessKeyId: string, _secretAccessKey: string);
+    accessKeyId(): string;
+    secretAccessKey(): string;
+    apiEndpoint(): string;
+    webuiEndpoint(): string;
+    stop(): Promise<void>;
+}

package/types/mysql.d.ts

@@ -0,0 +1,20 @@
+import { GenericService } from './genericService.js';
+export declare class MySQL {
+    private _service;
+    private _rootPassword;
+    private _db;
+    static start({ db, rootPassword }?: {
+        db?: string | undefined;
+        rootPassword?: string | undefined;
+    }): Promise<MySQL>;
+    constructor(_service: GenericService, _rootPassword: string, _db: string);
+    databaseUrl(): string;
+    connectOptions(): {
+        host: string;
+        port: number;
+        database: string;
+        user: string;
+        password: string;
+    };
+    stop(): Promise<void>;
+}

package/types/postgres.d.ts

@@ -0,0 +1,22 @@
+import { GenericService } from './genericService.js';
+export declare class Postgres {
+    private _service;
+    private _user;
+    private _password;
+    private _db;
+    static start({ user, password, db }?: {
+        user?: string | undefined;
+        password?: string | undefined;
+        db?: string | undefined;
+    }): Promise<Postgres>;
+    constructor(_service: GenericService, _user: string, _password: string, _db: string);
+    databaseUrl(): string;
+    connectOptions(): {
+        host: string;
+        port: number;
+        database: string;
+        user: string;
+        password: string;
+    };
+    stop(): Promise<void>;
+}