dsmt 0.1.1 → 0.2.0

package/README.md

@@ -1,6 +1,6 @@
 # 🐳 Docker Storage Migration Tool 📦
 
-A command-line utility for seamlessly exporting and importing Docker volumes and bind mounts.
+`dsmt` is a command-line utility for seamlessly exporting and importing Docker volumes and bind mounts.
 
 ## 🔍 Overview
 
@@ -52,7 +52,7 @@ dsmt import /path/to/tarball.tar.gz /path/to/bind/mount
 Both commands support the following options:
 
 - `-v, --volume`: Explicitly specify source/destination as a Docker volume
-- `-m, --mount`: Explicitly specify source/destination as a bind mount
+- `-b, --bind`: Explicitly specify source/destination as a bind mount
 
 The tool will automatically detect the source/destination type in most cases, but you can use these flags to be explicit.
 

package/SECURITY.md

@@ -4,7 +4,7 @@
 
 | Version | Supported          |
 | ------- | ------------------ |
-| > 0.1.0 | :white_check_mark: |
+| > 0.2.0 | :white_check_mark: |
 
 ## Reporting a Vulnerability
 

package/dist/cli.js

@@ -6,13 +6,13 @@ const program = new Command();
 program
     .name("dsmt")
     .description("Docker Storage Migration Tool")
-    .version("0.1.0");
+    .version("0.2.0");
 program
     .command("export")
     .argument("<src>", "volume name or bind mount path")
     .argument("<dst>", "path to export to")
     .option("-v, --volume", "Volume")
-    .option("-m, --mount", "Mount")
+    .option("-b, --bind", "Bind Mount")
     .description("Export a Docker Volume or Bind Mount to a Tarball")
     .action(async (src, dst, options) => await exportCmd(src, dst, options));
 program
@@ -20,7 +20,7 @@ program
     .argument("<src>", "path to import from")
     .argument("<dst>", "volume name or bind mount path")
     .option("-v, --volume", "Volume")
-    .option("-m, --mount", "Mount")
+    .option("-b, --bind", "Bind Mount")
     .description("Import a Docker Volume or Bind Mount from a Tarball")
     .action(async (src, dst, options) => await importCmd(src, dst, options));
 program.parse(process.argv);

package/dist/cmd/export.js

@@ -3,14 +3,15 @@ import chalk from "chalk";
 import ora from "ora";
 import path from "path";
 import { ensureAbsolutePath } from "../lib/etc/utils.js";
+const image = "busybox:latest";
 export default async function exportCmd(src, dst, options) {
-    if (options.volume && options.mount) {
-        console.error(chalk.red("Cannot use both --volume and --mount options at the same time."));
+    if (options.volume && options.bind) {
+        console.error(chalk.red("Cannot use both --volume and --bind options at the same time."));
         process.exit(1);
     }
-    if (!options.volume && !options.mount) {
-        if (src.startsWith("/") || src.startsWith("./") || src.startsWith("../")) {
-            options.mount = true;
+    if (!options.volume && !options.bind) {
+        if (src.includes("/") || src.includes("\\")) {
+            options.bind = true;
             console.log(chalk.blue(`Auto-detected bind mount path: ${src}`));
         }
         else {
@@ -19,13 +20,13 @@ export default async function exportCmd(src, dst, options) {
         }
     }
     if (options.volume) {
-        await exportVolume(src, dst, options);
+        await exportVolume(src, dst);
     }
-    else if (options.mount) {
-        await exportMount(src, dst, options);
+    else if (options.bind) {
+        await exportBind(src, dst);
     }
 }
-async function exportMount(src, dst, options) {
+async function exportBind(src, dst) {
     const spinner = ora("Preparing to export Docker bind mount...").start();
     try {
         const srcPath = ensureAbsolutePath(src);
@@ -33,11 +34,22 @@ async function exportMount(src, dst, options) {
         const name = path.basename(srcPath);
         spinner.text = `Exporting bind mount from ${chalk.blue(srcPath)} to ${chalk.green(dst)}`;
         await docker.run({
-            name: name,
-            src: srcPath,
-            dst: dstPath,
-            cmd: ["tar", "czf", `/dst/${name}.tar.gz`, "-C", "/src", "."],
-            options,
+            name: `dsmt-export-${name}`,
+            rm: true,
+            mounts: [
+                {
+                    Type: "bind",
+                    Source: srcPath,
+                    Target: "/src",
+                },
+                {
+                    Type: "bind",
+                    Source: dstPath,
+                    Target: "/dst",
+                },
+            ],
+            image: image,
+            cmdArgs: ["tar", "czf", `/dst/${name}.tar.gz`, "-C", "/src", "."],
         });
         spinner.succeed(`Successfully exported bind mount to ${chalk.green(dstPath)}`);
     }
@@ -46,7 +58,7 @@ async function exportMount(src, dst, options) {
         process.exit(1);
     }
 }
-async function exportVolume(src, dst, options) {
+async function exportVolume(src, dst) {
     const spinner = ora("Preparing to export Docker volume...").start();
     try {
         const volumeName = src;
@@ -54,11 +66,22 @@ async function exportVolume(src, dst, options) {
         const name = path.basename(src);
         spinner.text = `Exporting volume ${chalk.blue(src)} to ${chalk.green(dstPath)}`;
         await docker.run({
-            name: name,
-            src: volumeName,
-            dst: dstPath,
-            cmd: ["tar", "czf", `/dst/${name}.tar.gz`, "-C", "/src", "."],
-            options,
+            name: `dsmt-export-${name}`,
+            rm: true,
+            mounts: [
+                {
+                    Type: "volume",
+                    Source: volumeName,
+                    Target: "/src",
+                },
+                {
+                    Type: "bind",
+                    Source: dstPath,
+                    Target: "/dst",
+                },
+            ],
+            image,
+            cmdArgs: ["tar", "czf", `/dst/${name}.tar.gz`, "-C", "/src", "."],
         });
         spinner.succeed(`Successfully exported volume to ${chalk.green(dstPath)}`);
     }

package/dist/cmd/import.js

@@ -4,14 +4,15 @@ import ora from "ora";
 import path from "path";
 import fs from "fs";
 import { ensureAbsolutePath } from "../lib/etc/utils.js";
+const image = "busybox:latest";
 export default async function importCmd(src, dst, options) {
-    if (options.volume && options.mount) {
-        console.error(chalk.red("Cannot use both --volume and --mount options at the same time."));
+    if (options.volume && options.bind) {
+        console.error(chalk.red("Cannot use both --volume and --bind options at the same time."));
         process.exit(1);
     }
-    if (!options.volume && !options.mount) {
-        if (dst.startsWith("/") || dst.startsWith("./") || dst.startsWith("../")) {
-            options.mount = true;
+    if (!options.volume && !options.bind) {
+        if (dst.includes("/") || dst.includes("\\")) {
+            options.bind = true;
             console.log(chalk.blue(`Auto-detected bind mount path: ${dst}`));
         }
         else {
@@ -20,13 +21,13 @@ export default async function importCmd(src, dst, options) {
         }
     }
     if (options.volume) {
-        await importVolume(src, dst, options);
+        await importVolume(src, dst);
     }
-    else if (options.mount) {
-        await importMount(src, dst, options);
+    else if (options.bind) {
+        await importBind(src, dst);
     }
 }
-async function importMount(src, dst, options) {
+async function importBind(src, dst) {
     const spinner = ora("Preparing to import to Docker bind mount...").start();
     try {
         const srcPath = ensureAbsolutePath(src);
@@ -35,13 +36,25 @@ async function importMount(src, dst, options) {
             throw new Error(`Source file ${srcPath} does not exist`);
         }
         const name = path.basename(srcPath);
+        const srcDir = path.dirname(srcPath);
         spinner.text = `Importing from ${chalk.blue(srcPath)} to bind mount ${chalk.green(dstPath)}`;
         await docker.run({
-            name: name,
-            src: srcPath,
-            dst: dstPath,
-            cmd: ["tar", "xzf", `/src/${name}`, "-C", "/dst"],
-            options,
+            name: `dsmt-import-${name}`,
+            rm: true,
+            mounts: [
+                {
+                    Type: "bind",
+                    Source: srcDir,
+                    Target: "/src",
+                },
+                {
+                    Type: "bind",
+                    Source: dstPath,
+                    Target: "/dst",
+                },
+            ],
+            image: image,
+            cmdArgs: ["tar", "xzf", `/src/${name}`, "-C", "/dst"],
         });
         spinner.succeed(`Successfully imported to bind mount at ${chalk.green(dstPath)}`);
     }
@@ -50,7 +63,7 @@ async function importMount(src, dst, options) {
         process.exit(1);
     }
 }
-async function importVolume(src, dst, options) {
+async function importVolume(src, dst) {
     const spinner = ora("Preparing to import to Docker volume...").start();
     try {
         const srcPath = ensureAbsolutePath(src);
@@ -59,13 +72,25 @@ async function importVolume(src, dst, options) {
             throw new Error(`Source file ${srcPath} does not exist`);
         }
         const name = path.basename(srcPath);
+        const srcDir = path.dirname(srcPath);
         spinner.text = `Importing from ${chalk.blue(srcPath)} to volume ${chalk.green(volumeName)}`;
         await docker.run({
-            name: name,
-            src: srcPath,
-            dst: volumeName,
-            cmd: ["tar", "xzf", `/src/${name}`, "-C", "/dst"],
-            options,
+            name: `dsmt-import-${name}`,
+            rm: true,
+            mounts: [
+                {
+                    Type: "bind",
+                    Source: srcDir,
+                    Target: "/src",
+                },
+                {
+                    Type: "volume",
+                    Source: volumeName,
+                    Target: "/dst",
+                },
+            ],
+            image: image,
+            cmdArgs: ["tar", "xzf", `/src/${name}`, "-C", "/dst"],
         });
         spinner.succeed(`Successfully imported to volume ${chalk.green(volumeName)}`);
     }

package/dist/lib/connection/checks.js

@@ -0,0 +1,23 @@
+import fs from "fs";
+import os from "os";
+export function isSocketAccessible(socketPath) {
+    try {
+        const stats = fs.statSync(socketPath);
+        return stats.isSocket();
+    }
+    catch {
+        return false;
+    }
+}
+export function isNamedPipeAccessible(pipePath) {
+    if (os.platform() !== "win32") {
+        return false;
+    }
+    try {
+        const stats = fs.statSync(pipePath);
+        return stats.isFIFO();
+    }
+    catch {
+        return false;
+    }
+}

package/dist/lib/connection/client.js

@@ -0,0 +1,48 @@
+import os from "os";
+import chalk from "chalk";
+import axios from "axios";
+import { createNamedPipeAgent } from "./npipe.js";
+import { getBestDockerConnection } from "./optimal.js";
+export async function dockerClient(endpoint, options = {}) {
+    const dockerConfig = await initializeDockerConnection();
+    const config = createDockerAxiosConfig(dockerConfig, endpoint, options);
+    return axios(config);
+}
+export async function initializeDockerConnection() {
+    try {
+        const dockerConfig = await getBestDockerConnection();
+        return dockerConfig;
+    }
+    catch (error) {
+        console.error(chalk.red("Failed to connect to Docker:"), error.message);
+        console.error(chalk.yellow("Make sure Docker is running and accessible."));
+        process.exit(1);
+    }
+}
+function createDockerAxiosConfig(dockerConfig, endpoint, options = {}) {
+    // const dockerConfig = getDockerConfig();
+    const config = {
+        ...options,
+        url: `http://localhost${endpoint}`,
+    };
+    if (dockerConfig.socketPath) {
+        // Handle Windows named pipes differently
+        if (os.platform() === "win32" && dockerConfig.socketPath.includes("pipe")) {
+            // For Windows named pipes, we need to use a custom HTTP agent
+            config.httpAgent = createNamedPipeAgent(dockerConfig.socketPath);
+            config.baseURL = "http://localhost";
+        }
+        else {
+            // Unix socket
+            config.socketPath = dockerConfig.socketPath;
+        }
+    }
+    else if (dockerConfig.host && dockerConfig.port) {
+        // TCP connection
+        config.baseURL = `http://${dockerConfig.host}:${dockerConfig.port}`;
+    }
+    else {
+        throw new Error("Invalid Docker connection configuration");
+    }
+    return config;
+}

package/dist/lib/connection/linux.js

@@ -0,0 +1,23 @@
+import os from "os";
+import path from "path";
+import { parseDockerHost } from "./parser.js";
+import { isSocketAccessible } from "./checks.js";
+export function detectLinuxDockerConnection() {
+    const socketPaths = [
+        "/var/run/docker.sock", // Standard Docker socket
+        path.join(os.homedir(), ".docker", "desktop", "docker.sock"), // Rootless Docker
+        // Podman
+        `/run/user/${process.getuid?.() || 1000}/podman/podman.sock`,
+        path.join(os.homedir(), ".local", "share", "containers", "podman", "machine", "podman.sock"),
+    ];
+    for (const socketPath of socketPaths) {
+        if (isSocketAccessible(socketPath)) {
+            return { socketPath };
+        }
+    }
+    const dockerHost = process.env.DOCKER_HOST;
+    if (dockerHost) {
+        return parseDockerHost(dockerHost);
+    }
+    return { socketPath: "/var/run/docker.sock" };
+}

package/dist/lib/connection/macos.js

@@ -0,0 +1,27 @@
+import os from "os";
+import path from "path";
+import { parseDockerHost } from "./parser.js";
+import { isSocketAccessible } from "./checks.js";
+export function detectMacDockerConnection() {
+    const socketPaths = [
+        // Docker Desktop for Mac
+        path.join(os.homedir(), ".docker", "desktop", "docker.sock"),
+        path.join(os.homedir(), ".docker", "run", "docker.sock"),
+        // Standard Unix socket
+        "/var/run/docker.sock",
+        // Colima
+        path.join(os.homedir(), ".colima", "default", "docker.sock"),
+        // Podman Desktop
+        path.join(os.homedir(), ".local", "share", "containers", "podman", "machine", "podman.sock"),
+    ];
+    for (const socketPath of socketPaths) {
+        if (isSocketAccessible(socketPath)) {
+            return { socketPath };
+        }
+    }
+    const dockerHost = process.env.DOCKER_HOST;
+    if (dockerHost) {
+        return parseDockerHost(dockerHost);
+    }
+    return { socketPath: "/var/run/docker.sock" };
+}

package/dist/lib/connection/npipe.js

@@ -0,0 +1,19 @@
+import net from "net";
+import http from "http";
+function createNamedPipeAgent(pipePath) {
+    const agent = new http.Agent();
+    agent.createConnection = function (options, callback) {
+        const socket = net.createConnection(pipePath);
+        socket.on("connect", () => {
+            if (callback)
+                callback(null, socket);
+        });
+        socket.on("error", (err) => {
+            if (callback)
+                callback(err);
+        });
+        return socket;
+    };
+    return agent;
+}
+export { createNamedPipeAgent };

package/dist/lib/connection/optimal.js

@@ -0,0 +1,55 @@
+import os from "os";
+import path from "path";
+import { detectWindowsDockerConnection } from "./windows.js";
+import { detectMacDockerConnection } from "./macos.js";
+import { detectLinuxDockerConnection } from "./linux.js";
+import { testDockerConnection } from "./test.js";
+export function detectDockerConnection() {
+    const platform = os.platform();
+    switch (platform) {
+        case "win32":
+            return detectWindowsDockerConnection();
+        case "darwin":
+            return detectMacDockerConnection();
+        case "linux":
+            return detectLinuxDockerConnection();
+        default:
+            return detectLinuxDockerConnection();
+    }
+}
+export async function getBestDockerConnection() {
+    const primaryConfig = detectDockerConnection();
+    if (await testDockerConnection(primaryConfig)) {
+        return primaryConfig;
+    }
+    const fallbackConfigs = [];
+    // Platform-specific fallbacks
+    if (os.platform() === "win32") {
+        // Windows Docker Desktop named pipes
+        fallbackConfigs.push({ socketPath: "\\\\.\\pipe\\dockerDesktopLinuxEngine" }, { socketPath: "\\\\.\\pipe\\docker_engine" }, { socketPath: "\\\\.\\pipe\\dockerWindowsEngine" }, { host: "localhost", port: 2375 }, { host: "localhost", port: 2376 });
+    }
+    else if (os.platform() === "darwin") {
+        // macOS specific paths
+        fallbackConfigs.push({
+            socketPath: path.join(os.homedir(), ".docker", "desktop", "docker.sock"),
+        }, { socketPath: path.join(os.homedir(), ".docker", "run", "docker.sock") }, {
+            socketPath: path.join(os.homedir(), ".colima", "default", "docker.sock"),
+        }, { socketPath: "/var/run/docker.sock" }, { host: "localhost", port: 2375 }, { host: "localhost", port: 2376 });
+    }
+    else {
+        // Linux and other Unix-like systems
+        fallbackConfigs.push({ socketPath: "/var/run/docker.sock" }, {
+            socketPath: path.join(os.homedir(), ".docker", "desktop", "docker.sock"),
+        }, {
+            socketPath: `/run/user/${process.getuid?.() || 1000}/podman/podman.sock`,
+        }, { host: "localhost", port: 2375 }, { host: "localhost", port: 2376 });
+    }
+    for (const config of fallbackConfigs) {
+        if (await testDockerConnection(config)) {
+            return config;
+        }
+    }
+    throw new Error(`Failed to connect to Docker. Tried primary config: ${JSON.stringify(primaryConfig)} ` +
+        `and ${fallbackConfigs.length} fallback configurations. ` +
+        `Make sure Docker is running and accessible.`);
+}

package/dist/lib/connection/parser.js

@@ -0,0 +1,26 @@
+export function parseDockerHost(dockerHost) {
+    try {
+        if (dockerHost.startsWith("npipe:")) {
+            const pipePath = dockerHost.replace("npipe:////./pipe/", "\\\\.\\pipe\\");
+            return { socketPath: pipePath };
+        }
+        const url = new URL(dockerHost);
+        switch (url.protocol) {
+            case "unix:":
+                return { socketPath: url.pathname };
+            case "tcp:":
+                return {
+                    host: url.hostname || "localhost",
+                    port: parseInt(url.port) || 2376,
+                };
+            case "npipe:":
+                return { socketPath: url.pathname };
+            default:
+                throw new Error(`Unsupported protocol: ${url.protocol}`);
+        }
+    }
+    catch (error) {
+        console.warn(`Failed to parse DOCKER_HOST "${dockerHost}":`, error);
+        return { socketPath: "/var/run/docker.sock" };
+    }
+}

package/dist/lib/connection/test.js

@@ -0,0 +1,77 @@
+import os from "os";
+import http from "http";
+import { createNamedPipeAgent } from "./npipe.js";
+export async function testDockerConnection(config) {
+    try {
+        if (config.socketPath) {
+            // Handle Windows named pipes specially
+            if (os.platform() === "win32" && config.socketPath.includes("pipe")) {
+                return await testWindowsNamedPipe(config.socketPath);
+            }
+            else {
+                // Unix socket connection
+                const axios = (await import("axios")).default;
+                const axiosConfig = {
+                    method: "GET",
+                    url: "http://localhost/_ping",
+                    socketPath: config.socketPath,
+                    timeout: 5000,
+                };
+                const response = await axios(axiosConfig);
+                return response.status === 200 && response.data === "OK";
+            }
+        }
+        else if (config.host && config.port) {
+            // TCP connection
+            const axios = (await import("axios")).default;
+            const axiosConfig = {
+                method: "GET",
+                baseURL: `http://${config.host}:${config.port}`,
+                url: "/_ping",
+                timeout: 5000,
+            };
+            const response = await axios(axiosConfig);
+            return response.status === 200 && response.data === "OK";
+        }
+        else {
+            return false;
+        }
+    }
+    catch {
+        return false;
+    }
+}
+export async function testWindowsNamedPipe(pipePath) {
+    if (os.platform() !== "win32") {
+        return false;
+    }
+    return new Promise((resolve) => {
+        const agent = createNamedPipeAgent(pipePath);
+        const options = {
+            agent: agent,
+            hostname: "localhost",
+            port: 80,
+            path: "/_ping",
+            method: "GET",
+            timeout: 5000,
+        };
+        const req = http.request(options, (res) => {
+            let data = "";
+            res.on("data", (chunk) => {
+                data += chunk;
+            });
+            res.on("end", () => {
+                resolve(res.statusCode === 200 && data.trim() === "OK");
+            });
+        });
+        req.on("error", () => {
+            resolve(false);
+        });
+        req.on("timeout", () => {
+            req.destroy();
+            resolve(false);
+        });
+        req.setTimeout(5000);
+        req.end();
+    });
+}

package/dist/lib/connection/windows.js

@@ -0,0 +1,66 @@
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { execSync } from "child_process";
+import { parseDockerHost } from "./parser.js";
+import { isNamedPipeAccessible } from "./checks.js";
+export function detectWindowsDockerConnection() {
+    // Check if DOCKER_HOST environment variable is set to a named pipe
+    const dockerHost = process.env.DOCKER_HOST;
+    if (dockerHost && dockerHost.startsWith("npipe:")) {
+        return parseDockerHost(dockerHost);
+    }
+    // Check if Docker context is set to a named pipe
+    try {
+        const contextName = execSync("docker context show", {
+            encoding: "utf8",
+        }).trim();
+        const contextInfo = JSON.parse(execSync(`docker context inspect ${contextName}`, { encoding: "utf8" }));
+        if (contextInfo &&
+            contextInfo[0] &&
+            contextInfo[0].Endpoints &&
+            contextInfo[0].Endpoints.docker) {
+            const dockerEndpoint = contextInfo[0].Endpoints.docker.Host;
+            if (dockerEndpoint && dockerEndpoint.startsWith("npipe:")) {
+                return parseDockerHost(dockerEndpoint);
+            }
+        }
+    }
+    catch (error) {
+        console.debug("Could not detect Docker context:", error);
+    }
+    // Common Docker Desktop named pipe paths
+    const namedPipePaths = [
+        "\\\\.\\pipe\\dockerDesktopLinuxEngine", // Docker Desktop Linux containers
+        "\\\\.\\pipe\\docker_engine", // Default Docker engine
+        "\\\\.\\pipe\\dockerWindowsEngine", // Docker Desktop Windows containers
+    ];
+    // Check if any named pipe exists
+    for (const pipePath of namedPipePaths) {
+        if (isNamedPipeAccessible(pipePath)) {
+            return { socketPath: pipePath };
+        }
+    }
+    // Check if Docker Desktop is installed
+    const dockerDesktopPaths = [
+        path.join(os.homedir(), "AppData", "Roaming", "Docker", "settings.json"),
+        path.join(os.homedir(), "AppData", "Local", "Docker", "settings.json"),
+    ];
+    const isDockerDesktopInstalled = dockerDesktopPaths.some((p) => {
+        try {
+            return fs.existsSync(p);
+        }
+        catch {
+            return false;
+        }
+    });
+    if (isDockerDesktopInstalled) {
+        // Return the most common Docker Desktop pipe
+        return { socketPath: "\\\\.\\pipe\\dockerDesktopLinuxEngine" };
+    }
+    // Fallback to TCP for other Docker implementations on Windows
+    return {
+        host: "localhost",
+        port: 2375,
+    };
+}

package/dist/lib/docker/container.js

@@ -1,19 +1,13 @@
-import axios from "axios";
-export async function containerCreate({ name, src, dst, cmd, image, }) {
-    const binds = [`${src}:/src`, `${dst}:/dst`];
+import { dockerClient } from "../connection/client.js";
+export async function containerCreate(name, { Image, Cmd, Tty = false, HostConfig }) {
     try {
-        const createResponse = await axios({
+        const createResponse = await dockerClient(`/containers/create${name ? `?name=${name}` : ""}`, {
             method: "POST",
-            socketPath: "/var/run/docker.sock",
-            url: `http://localhost/containers/create`,
             data: {
-                Image: image,
-                Tty: false,
-                Cmd: cmd,
-                HostConfig: {
-                    AutoRemove: true,
-                    Binds: binds,
-                },
+                Image,
+                Cmd,
+                Tty,
+                HostConfig,
             },
         });
         if (!createResponse.data || !createResponse.data.Id) {
@@ -28,10 +22,8 @@ export async function containerCreate({ name, src, dst, cmd, image, }) {
 }
 export async function containerStart(containerId) {
     try {
-        await axios({
+        await dockerClient(`/containers/${containerId}/start`, {
             method: "POST",
-            socketPath: "/var/run/docker.sock",
-            url: `http://localhost/containers/${containerId}/start`,
         });
     }
     catch (error) {
@@ -42,10 +34,8 @@ export async function containerStart(containerId) {
 }
 export async function containerWait(containerId) {
     try {
-        const response = await axios({
+        const response = await dockerClient(`/containers/${containerId}/wait`, {
             method: "POST",
-            socketPath: "/var/run/docker.sock",
-            url: `http://localhost/containers/${containerId}/wait`,
         });
         if (response.data.StatusCode !== 0) {
             throw new Error(`Container ${containerId} exited with status code ${response.data.StatusCode}`);
@@ -59,10 +49,8 @@ export async function containerWait(containerId) {
 }
 export async function containerRemove(containerId) {
     try {
-        await axios({
+        await dockerClient(`/containers/${containerId}`, {
             method: "DELETE",
-            socketPath: "/var/run/docker.sock",
-            url: `http://localhost/containers/${containerId}`,
         });
     }
     catch (error) {

package/dist/lib/docker/image.js

@@ -1,10 +1,8 @@
-import axios from "axios";
+import { dockerClient } from "../connection/client.js";
 export async function imageList() {
     try {
-        const response = await axios({
+        const response = await dockerClient("/images/json", {
             method: "GET",
-            socketPath: "/var/run/docker.sock",
-            url: `http://localhost/images/json`,
         });
         return response.data
             .map((image) => image.RepoTags)
@@ -18,10 +16,8 @@ export async function imageList() {
 }
 export async function imagePull(image) {
     try {
-        const response = await axios({
+        const response = await dockerClient(`/images/create?fromImage=${image}`, {
             method: "POST",
-            socketPath: "/var/run/docker.sock",
-            url: `http://localhost/images/create?fromImage=${image}`,
         });
         return response.data;
     }

package/dist/lib/docker/sdk.js

@@ -1,13 +1,29 @@
-const image = "busybox:latest";
 import { containerCreate, containerStart, containerWait, containerRemove, } from "./container.js";
 import { imageList, imagePull } from "./image.js";
-export async function run({ name, src, dst, cmd }) {
-    const localImages = await imageList();
-    const isImageFound = localImages.some((localImage) => localImage === image);
-    if (!isImageFound) {
-        await imagePull(image);
-    }
-    const containerId = await containerCreate({ name, src, dst, cmd, image });
+import { volumeCreate, volumeList } from "./volume.js";
+/**
+ * @description Create and run a new container from an image
+ * @param options - Options for running the container
+ */
+export async function run(options) {
+    const { name, rm, mounts, volumes, tty, image, cmdArgs } = options;
+    let hostConfig = {
+        AutoRemove: rm,
+        Binds: volumes?.map((v) => `${v.Name}:${v.Mountpoint}`),
+        Mounts: mounts?.map((m) => ({
+            Type: m.Type,
+            Source: m.Source,
+            Target: m.Target,
+            ReadOnly: m.ReadOnly,
+            Consistency: m.Consistency,
+        })),
+    };
+    const containerId = await containerCreate(name, {
+        HostConfig: hostConfig,
+        Tty: tty || false,
+        Image: image,
+        Cmd: cmdArgs,
+    });
     await containerStart(containerId);
     await containerWait(containerId);
 }
@@ -19,5 +35,7 @@ const docker = {
     containerRemove,
     imageList,
     imagePull,
+    volumeList,
+    volumeCreate,
 };
 export default docker;

package/dist/lib/docker/volume.js

@@ -0,0 +1,44 @@
+import { dockerClient } from "../connection/client.js";
+export async function volumeList() {
+    try {
+        const response = await dockerClient("/volumes", {
+            method: "GET",
+        });
+        const data = response.data;
+        const volumes = data.Volumes.map((vol) => {
+            return {
+                Name: vol.Name,
+                Driver: vol.Driver,
+                Mountpoint: vol.Mountpoint,
+            };
+        });
+        return volumes;
+    }
+    catch (error) {
+        console.error("Failed to list Docker volumes:", error);
+        throw error;
+    }
+}
+export async function volumeCreate({ Name, Driver }) {
+    if (!Name) {
+        throw new Error("Volume name is required for creation.");
+    }
+    if (!Driver) {
+        Driver = "local";
+    }
+    try {
+        const response = await dockerClient("/volumes/create", {
+            method: "POST",
+            data: {
+                Name,
+                Driver,
+            },
+        });
+        const data = response.data;
+        return data;
+    }
+    catch (error) {
+        console.error(`Failed to create Docker volume ${Name}:`, error);
+        throw error;
+    }
+}

package/dist/lib/etc/utils.js

@@ -1,4 +1,14 @@
 import path from "path";
+import { volumeList } from "../docker/volume.js";
 export function ensureAbsolutePath(p) {
     return path.isAbsolute(p) ? p : path.resolve(process.cwd(), p);
 }
+export async function volumeExists(name) {
+    try {
+        const volumes = await volumeList();
+        return volumes.map((v) => v.Name).includes(name);
+    }
+    catch (error) {
+        return false;
+    }
+}

package/dist/types/container.js

@@ -0,0 +1 @@
+export {};

package/dist/types/volume.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsmt",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "Docker Storage Migration Tool",
   "type": "module",
   "bin": {