dsmt 0.1.0 → 0.2.0

package/CONTRIBUTING.md

@@ -0,0 +1,99 @@
+# Contributing to Docker Storage Migration Tool (DSMT)
+
+Thank you for considering contributing to DSMT! This document provides guidelines and instructions to help you contribute effectively.
+
+## Code of Conduct
+
+This project adheres to the Contributor Covenant Code of Conduct. By participating, you are expected to uphold this code.
+
+## How Can I Contribute?
+
+### Reporting Bugs
+
+Before submitting a bug report:
+
+- Check the [issue tracker](https://github.com/itskdhere/dsmt/issues) to see if the issue has already been reported
+- If you're unable to find an open issue addressing the problem, [open a new one](https://github.com/itskdhere/dsmt/issues/new?template=bug_report.md)
+
+When filing a bug report, please include:
+
+- A clear and descriptive title
+- Steps to reproduce the issue
+- Expected and actual behavior
+- System information (OS, Docker version, Node.js version)
+- Any relevant logs or error messages
+
+### Suggesting Features
+
+We welcome feature suggestions! [Open an issue](https://github.com/itskdhere/dsmt/issues/new?template=feature_request.md) with your idea, providing as much context and detail as possible.
+
+### Pull Requests
+
+1. Fork the repository
+2. Create a new branch for your feature or bugfix
+3. Make your changes
+4. Ensure your code follows the project style and passes all tests
+5. Submit a pull request
+
+## Development Setup
+
+```bash
+# Clone your fork of the repo
+git clone https://github.com/YOUR-USERNAME/dsmt.git
+cd dsmt
+
+# Install dependencies
+npm install
+
+# Start development mode (watches for changes)
+npm run dev
+
+# Link the package globally for testing
+npm link
+```
+
+## Project Structure
+
+- cli.ts - CLI entry point
+- cmd - Command implementations
+- docker - Docker API wrapper
+- types - TypeScript type definitions
+
+## Coding Guidelines
+
+- Use TypeScript for all new code
+- Follow existing code style (2 spaces for indentation)
+- Add appropriate error handling and logging
+- Document new functions and methods
+
+## Commit Messages
+
+- Use the present tense ("Add feature" not "Added feature")
+- Use the imperative mood ("Move cursor to..." not "Moves cursor to...")
+- Limit the first line to 72 characters
+- Reference issues and pull requests liberally after the first line
+
+## Testing Your Changes
+
+Please ensure your changes work properly with:
+
+- Different types of Docker volumes
+- Bind mounts with various path structures
+- Different operating systems (if possible)
+
+## Submitting Changes
+
+1. Push your changes to your fork
+2. Submit a pull request to the main repository
+3. The title of your PR should clearly describe the change
+4. Link any relevant issues in the PR description
+
+## License
+
+By contributing to DSMT, you agree that your contributions will be licensed under the project's MIT License.
+
+## Questions?
+
+Feel free to open an issue if you have any questions about contributing.
+
+Thank you for contributing to DSMT!

package/README.md

@@ -1,6 +1,6 @@
-# 🐳 Docker Storage Migration Tool (DSMT) 📦
+# 🐳 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.
 
@@ -72,19 +72,13 @@ dsmt export /var/www/html /backups
 dsmt import ./html.tar.gz /var/www/html
 ```
 
-## 🛠️ Development
+## 🛠️ Contribution
 
-```bash
-# Clone the repository
-git clone https://github.com/itskdhere/dsmt.git
-cd dsmt
+Please refer to the [CONTRIBUTING.md](CONTRIBUTING.md) file for guidelines on contributing to this project.
 
-# Install dependencies
-npm install
+## 🔒 Security
 
-# Run the development build
-npm run dev
-```
+Please refer to the [SECURITY.md](SECURITY.md) file for security-related issues and reporting.
 
 ## 📄 License
 

package/SECURITY.md

@@ -0,0 +1,12 @@
+# Security Policy
+
+## Supported Versions
+
+| Version | Supported          |
+| ------- | ------------------ |
+| > 0.2.0 | :white_check_mark: |
+
+## Reporting a Vulnerability
+
+:octocat: https://github.com/itskdhere/dsmt/security/advisories/new  
+📧 [support@itskdhere.eu.org](mailto:support@itskdhere.eu.org)

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.0",
+  "version": "0.2.0",
   "description": "Docker Storage Migration Tool",
   "type": "module",
   "bin": {

package/CODE_OF_CONDUCT.md

@@ -1,128 +0,0 @@
-# Contributor Covenant Code of Conduct
-
-## Our Pledge
-
-We as members, contributors, and leaders pledge to make participation in our
-community a harassment-free experience for everyone, regardless of age, body
-size, visible or invisible disability, ethnicity, sex characteristics, gender
-identity and expression, level of experience, education, socio-economic status,
-nationality, personal appearance, race, religion, or sexual identity
-and orientation.
-
-We pledge to act and interact in ways that contribute to an open, welcoming,
-diverse, inclusive, and healthy community.
-
-## Our Standards
-
-Examples of behavior that contributes to a positive environment for our
-community include:
-
-* Demonstrating empathy and kindness toward other people
-* Being respectful of differing opinions, viewpoints, and experiences
-* Giving and gracefully accepting constructive feedback
-* Accepting responsibility and apologizing to those affected by our mistakes,
-  and learning from the experience
-* Focusing on what is best not just for us as individuals, but for the
-  overall community
-
-Examples of unacceptable behavior include:
-
-* The use of sexualized language or imagery, and sexual attention or
-  advances of any kind
-* Trolling, insulting or derogatory comments, and personal or political attacks
-* Public or private harassment
-* Publishing others' private information, such as a physical or email
-  address, without their explicit permission
-* Other conduct which could reasonably be considered inappropriate in a
-  professional setting
-
-## Enforcement Responsibilities
-
-Community leaders are responsible for clarifying and enforcing our standards of
-acceptable behavior and will take appropriate and fair corrective action in
-response to any behavior that they deem inappropriate, threatening, offensive,
-or harmful.
-
-Community leaders have the right and responsibility to remove, edit, or reject
-comments, commits, code, wiki edits, issues, and other contributions that are
-not aligned to this Code of Conduct, and will communicate reasons for moderation
-decisions when appropriate.
-
-## Scope
-
-This Code of Conduct applies within all community spaces, and also applies when
-an individual is officially representing the community in public spaces.
-Examples of representing our community include using an official e-mail address,
-posting via an official social media account, or acting as an appointed
-representative at an online or offline event.
-
-## Enforcement
-
-Instances of abusive, harassing, or otherwise unacceptable behavior may be
-reported to the community leaders responsible for enforcement at
-kd@itskdhere.eu.org.
-All complaints will be reviewed and investigated promptly and fairly.
-
-All community leaders are obligated to respect the privacy and security of the
-reporter of any incident.
-
-## Enforcement Guidelines
-
-Community leaders will follow these Community Impact Guidelines in determining
-the consequences for any action they deem in violation of this Code of Conduct:
-
-### 1. Correction
-
-**Community Impact**: Use of inappropriate language or other behavior deemed
-unprofessional or unwelcome in the community.
-
-**Consequence**: A private, written warning from community leaders, providing
-clarity around the nature of the violation and an explanation of why the
-behavior was inappropriate. A public apology may be requested.
-
-### 2. Warning
-
-**Community Impact**: A violation through a single incident or series
-of actions.
-
-**Consequence**: A warning with consequences for continued behavior. No
-interaction with the people involved, including unsolicited interaction with
-those enforcing the Code of Conduct, for a specified period of time. This
-includes avoiding interactions in community spaces as well as external channels
-like social media. Violating these terms may lead to a temporary or
-permanent ban.
-
-### 3. Temporary Ban
-
-**Community Impact**: A serious violation of community standards, including
-sustained inappropriate behavior.
-
-**Consequence**: A temporary ban from any sort of interaction or public
-communication with the community for a specified period of time. No public or
-private interaction with the people involved, including unsolicited interaction
-with those enforcing the Code of Conduct, is allowed during this period.
-Violating these terms may lead to a permanent ban.
-
-### 4. Permanent Ban
-
-**Community Impact**: Demonstrating a pattern of violation of community
-standards, including sustained inappropriate behavior,  harassment of an
-individual, or aggression toward or disparagement of classes of individuals.
-
-**Consequence**: A permanent ban from any sort of public interaction within
-the community.
-
-## Attribution
-
-This Code of Conduct is adapted from the [Contributor Covenant][homepage],
-version 2.0, available at
-https://www.contributor-covenant.org/version/2/0/code_of_conduct.html.
-
-Community Impact Guidelines were inspired by [Mozilla's code of conduct
-enforcement ladder](https://github.com/mozilla/diversity).
-
-[homepage]: https://www.contributor-covenant.org
-
-For answers to common questions about this code of conduct, see the FAQ at
-https://www.contributor-covenant.org/faq. Translations are available at
-https://www.contributor-covenant.org/translations.