@wocker/ws 1.0.22 → 1.0.24

package/lib/env.d.ts

@@ -1,9 +1,8 @@
-export declare const WOCKER_VERSION = "1.0.22";
+export declare const WOCKER_VERSION = "1.0.24";
 export declare const NODE_ENV: string;
 export declare const ROOT_DIR: string;
 export declare const PRESETS_DIR: string;
-export declare const SERVICES_DIR: string;
 export declare const PLUGINS_DIR: string;
-export declare const DATA_DIR: string;
+export declare const WOCKER_DATA_DIR: string;
 export declare const VIRTUAL_HOST_KEY = "VIRTUAL_HOST";
 export declare const KEYTAR_SERVICE: string;

package/lib/env.js

@@ -33,15 +33,14 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.KEYTAR_SERVICE = exports.VIRTUAL_HOST_KEY = exports.DATA_DIR = exports.PLUGINS_DIR = exports.SERVICES_DIR = exports.PRESETS_DIR = exports.ROOT_DIR = exports.NODE_ENV = exports.WOCKER_VERSION = void 0;
+exports.KEYTAR_SERVICE = exports.VIRTUAL_HOST_KEY = exports.WOCKER_DATA_DIR = exports.PLUGINS_DIR = exports.PRESETS_DIR = exports.ROOT_DIR = exports.NODE_ENV = exports.WOCKER_VERSION = void 0;
 const OS = __importStar(require("os"));
 const Path = __importStar(require("path"));
-exports.WOCKER_VERSION = "1.0.22";
+exports.WOCKER_VERSION = "1.0.24";
 exports.NODE_ENV = process.env.NODE_ENV;
 exports.ROOT_DIR = Path.join(__dirname, "..");
 exports.PRESETS_DIR = Path.join(exports.ROOT_DIR, "presets");
-exports.SERVICES_DIR = Path.join(exports.ROOT_DIR, "services");
 exports.PLUGINS_DIR = Path.join(exports.ROOT_DIR, "plugins");
-exports.DATA_DIR = process.env.WS_DIR || Path.join(OS.homedir(), ".workspace");
+exports.WOCKER_DATA_DIR = process.env.WS_DIR || Path.join(OS.homedir(), ".workspace");
 exports.VIRTUAL_HOST_KEY = "VIRTUAL_HOST";
 exports.KEYTAR_SERVICE = process.env.WOCKER_KEYTAR_SERVICE || "wocker";

package/lib/main.js

@@ -6,15 +6,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.app = void 0;
 const core_1 = require("@wocker/core");
 const yoctocolors_cjs_1 = __importDefault(require("yoctocolors-cjs"));
-const AppModule_1 = require("./AppModule");
-const services_1 = require("./services");
+const RootModule_1 = require("./RootModule");
 exports.app = {
     async run(args) {
-        const app = await core_1.Factory.create(AppModule_1.AppModule);
-        const configService = app.get(services_1.AppConfigService);
-        const logger = app.get(services_1.LogService);
+        const context = await core_1.Factory.create(RootModule_1.RootModule), appConfigService = context.get(core_1.AppConfigService), logService = context.get(core_1.LogService);
         try {
-            const res = await app.run(args);
+            const res = await context.run(args);
             if (res) {
                 process.stdout.write(res);
                 process.stdout.write("\n");
@@ -25,11 +22,14 @@ exports.app = {
                 return;
             }
             console.error(yoctocolors_cjs_1.default.red(err.message));
+            if (err instanceof core_1.UsageException || err.name === "UsageException") {
+                return;
+            }
             if (err instanceof core_1.CommandNotFoundError) {
                 return;
             }
-            if (configService.config.debug) {
-                logger.error(err.stack || err.toString());
+            if (appConfigService.debug) {
+                logService.error(err.stack || err.toString());
             }
         }
     }

package/lib/makes/Plugin.d.ts

@@ -1,4 +1,3 @@
-import "reflect-metadata";
 export declare class Plugin {
     readonly type: any;
     readonly name: string;

package/lib/makes/Plugin.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Plugin = void 0;
-require("reflect-metadata");
 const core_1 = require("@wocker/core");
 class Plugin {
     constructor(type) {

package/lib/makes/index.d.ts

@@ -1,4 +1,2 @@
-export * from "./FS";
 export * from "./Http";
-export * from "./Logger";
 export * from "./Plugin";

package/lib/makes/index.js

@@ -14,7 +14,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./FS"), exports);
 __exportStar(require("./Http"), exports);
-__exportStar(require("./Logger"), exports);
 __exportStar(require("./Plugin"), exports);

package/lib/modules/app/index.d.ts

@@ -0,0 +1,2 @@
+export declare class AppModule {
+}

package/lib/modules/app/index.js

@@ -0,0 +1,32 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppModule = void 0;
+const core_1 = require("@wocker/core");
+const env_1 = require("../../env");
+let AppModule = class AppModule {
+};
+exports.AppModule = AppModule;
+exports.AppModule = AppModule = __decorate([
+    (0, core_1.Module)({
+        providers: [
+            {
+                provide: core_1.WOCKER_VERSION_KEY,
+                useValue: env_1.WOCKER_VERSION
+            },
+            {
+                provide: core_1.WOCKER_DATA_DIR_KEY,
+                useValue: env_1.WOCKER_DATA_DIR
+            }
+        ],
+        exports: [
+            core_1.WOCKER_VERSION_KEY,
+            core_1.WOCKER_DATA_DIR_KEY
+        ]
+    })
+], AppModule);

package/lib/modules/docker/index.d.ts

@@ -0,0 +1,8 @@
+import { ContainerService } from "./services/ContainerService";
+import { DockerService } from "./services/DockerService";
+import { ImageService } from "./services/ImageService";
+import { ModemService } from "./services/ModemService";
+import { ProtoService } from "./services/ProtoService";
+export declare class DockerModule {
+}
+export { ContainerService, DockerService, ImageService, ModemService, ProtoService };

package/lib/modules/docker/index.js

@@ -0,0 +1,41 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProtoService = exports.ModemService = exports.ImageService = exports.DockerService = exports.ContainerService = exports.DockerModule = void 0;
+const core_1 = require("@wocker/core");
+const ContainerService_1 = require("./services/ContainerService");
+Object.defineProperty(exports, "ContainerService", { enumerable: true, get: function () { return ContainerService_1.ContainerService; } });
+const DockerService_1 = require("./services/DockerService");
+Object.defineProperty(exports, "DockerService", { enumerable: true, get: function () { return DockerService_1.DockerService; } });
+const ImageService_1 = require("./services/ImageService");
+Object.defineProperty(exports, "ImageService", { enumerable: true, get: function () { return ImageService_1.ImageService; } });
+const ModemService_1 = require("./services/ModemService");
+Object.defineProperty(exports, "ModemService", { enumerable: true, get: function () { return ModemService_1.ModemService; } });
+const ProtoService_1 = require("./services/ProtoService");
+Object.defineProperty(exports, "ProtoService", { enumerable: true, get: function () { return ProtoService_1.ProtoService; } });
+let DockerModule = class DockerModule {
+};
+exports.DockerModule = DockerModule;
+exports.DockerModule = DockerModule = __decorate([
+    (0, core_1.Module)({
+        providers: [
+            ContainerService_1.ContainerService,
+            DockerService_1.DockerService,
+            ImageService_1.ImageService,
+            ModemService_1.ModemService,
+            ProtoService_1.ProtoService
+        ],
+        exports: [
+            ContainerService_1.ContainerService,
+            DockerService_1.DockerService,
+            ImageService_1.ImageService,
+            ModemService_1.ModemService,
+            ProtoService_1.ProtoService
+        ]
+    })
+], DockerModule);

package/lib/modules/docker/services/ContainerService.d.ts

@@ -0,0 +1,14 @@
+import { LogService, DockerServiceParams as Params } from "@wocker/core";
+import type Docker from "dockerode";
+import { Duplex } from "stream";
+import type { Container } from "dockerode";
+import { ModemService } from "./ModemService";
+export declare class ContainerService {
+    protected readonly logService: LogService;
+    protected readonly modemService: ModemService;
+    constructor(logService: LogService, modemService: ModemService);
+    get docker(): Docker;
+    get(name: string): Promise<Container>;
+    rm(name: string): Promise<void>;
+    exec(nameOrContainer: string | Container, options: Params.Exec | string[], _tty?: boolean): Promise<Duplex>;
+}

package/lib/modules/docker/services/ContainerService.js

@@ -0,0 +1,115 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContainerService = void 0;
+const core_1 = require("@wocker/core");
+const ModemService_1 = require("./ModemService");
+let ContainerService = class ContainerService {
+    constructor(logService, modemService) {
+        this.logService = logService;
+        this.modemService = modemService;
+    }
+    get docker() {
+        return this.modemService.docker;
+    }
+    async get(name) {
+        const containers = await this.docker.listContainers({
+            all: true,
+            filters: {
+                name: [name]
+            }
+        });
+        const container = containers.find((container) => {
+            return container.Names.indexOf("/" + name) >= 0;
+        });
+        if (!container) {
+            return null;
+        }
+        return this.docker.getContainer(container.Id);
+    }
+    async rm(name) {
+        const container = await this.get(name);
+        if (!container) {
+            return;
+        }
+        const { State: { Status } } = await container.inspect();
+        if (Status === "running" || Status === "restarting") {
+            try {
+                await container.stop();
+            }
+            catch (err) {
+                this.logService.error("DockerService.removeContainer", err.message);
+            }
+        }
+        try {
+            await container.remove();
+        }
+        catch (err) {
+            this.logService.error("DockerService.removeContainer: ", err.message);
+        }
+    }
+    async exec(nameOrContainer, options, _tty) {
+        const container = typeof nameOrContainer === "string"
+            ? await this.get(nameOrContainer)
+            : nameOrContainer;
+        if (!container) {
+            return;
+        }
+        const { cmd = [], tty = false, user } = Array.isArray(options) ? {
+            cmd: options,
+            tty: _tty
+        } : options;
+        const exec = await container.exec({
+            AttachStdin: true,
+            AttachStdout: true,
+            AttachStderr: true,
+            Tty: tty,
+            User: user,
+            Cmd: cmd,
+            ConsoleSize: [
+                process.stdout.rows,
+                process.stdout.columns
+            ]
+        });
+        const stream = await exec.start({
+            hijack: true,
+            stdin: tty,
+            Tty: tty
+        });
+        if (tty) {
+            const handleResize = async () => {
+                const [width, height] = process.stdout.getWindowSize();
+                this.logService.debug("Exec resize", {
+                    width,
+                    height
+                });
+                await exec.resize({
+                    w: width,
+                    h: height
+                });
+            };
+            process.on("SIGWINCH", handleResize);
+            try {
+                await this.modemService.attachStream(stream);
+            }
+            finally {
+                process.off("SIGWINCH", handleResize);
+            }
+        }
+        return stream;
+    }
+};
+exports.ContainerService = ContainerService;
+exports.ContainerService = ContainerService = __decorate([
+    (0, core_1.Injectable)(),
+    __metadata("design:paramtypes", [core_1.LogService,
+        ModemService_1.ModemService])
+], ContainerService);

package/lib/{services → modules/docker/services}/DockerService.d.ts

@@ -1,10 +1,16 @@
-import { DockerService as CoreDockerService, DockerServiceParams as Params } from "@wocker/core";
-import Docker, { Container, Volume, VolumeCreateResponse } from "dockerode";
-import { LogService } from "./LogService";
+import { DockerService as CoreDockerService, DockerServiceParams as Params, LogService } from "@wocker/core";
+import type Docker from "dockerode";
+import type { Container, Volume, VolumeCreateResponse } from "dockerode";
+import { ContainerService } from "./ContainerService";
+import { ModemService } from "./ModemService";
+import { ImageService } from "./ImageService";
 export declare class DockerService extends CoreDockerService {
+    protected readonly modemService: ModemService;
+    protected readonly containerService: ContainerService;
+    protected readonly imageService: ImageService;
     protected readonly logService: LogService;
-    protected docker: Docker;
-    constructor(logService: LogService);
+    constructor(modemService: ModemService, containerService: ContainerService, imageService: ImageService, logService: LogService);
+    get docker(): Docker;
     createVolume(name: string): Promise<VolumeCreateResponse>;
     hasVolume(name: string): Promise<boolean>;
     getVolume(name: string): Promise<Volume>;
@@ -21,4 +27,5 @@ export declare class DockerService extends CoreDockerService {
     attachStream(stream: NodeJS.ReadWriteStream): Promise<NodeJS.ReadWriteStream>;
     exec(nameOrContainer: string | Container, options: Params.Exec | string[], _tty?: boolean): Promise<import("stream").Duplex>;
     logs(containerOrName: string | Container): Promise<NodeJS.ReadableStream>;
+    followProgress(stream: NodeJS.ReadableStream): Promise<void>;
 }

package/lib/{services → modules/docker/services}/DockerService.js

@@ -8,23 +8,22 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DockerService = void 0;
 const core_1 = require("@wocker/core");
-const dockerode_1 = __importDefault(require("dockerode"));
-const utils_1 = require("../utils");
-const makes_1 = require("../makes");
-const LogService_1 = require("./LogService");
+const ContainerService_1 = require("./ContainerService");
+const ModemService_1 = require("./ModemService");
+const ImageService_1 = require("./ImageService");
 let DockerService = class DockerService extends core_1.DockerService {
-    constructor(logService) {
+    constructor(modemService, containerService, imageService, logService) {
         super();
+        this.modemService = modemService;
+        this.containerService = containerService;
+        this.imageService = imageService;
         this.logService = logService;
-        this.docker = new dockerode_1.default({
-            socketPath: "/var/run/docker.sock"
-        });
+    }
+    get docker() {
+        return this.modemService.docker;
     }
     async createVolume(name) {
         return await this.docker.createVolume({
@@ -136,44 +135,15 @@ let DockerService = class DockerService extends core_1.DockerService {
         });
     }
     async getContainer(name) {
-        const containers = await this.docker.listContainers({
-            all: true,
-            filters: {
-                name: [name]
-            }
-        });
-        const container = containers.find((container) => {
-            return container.Names.indexOf("/" + name) >= 0;
-        });
-        if (container) {
-            return this.docker.getContainer(container.Id);
-        }
-        return null;
+        return this.containerService.get(name);
     }
     async removeContainer(name) {
-        const container = await this.getContainer(name);
-        if (!container) {
-            return;
-        }
-        const { State: { Status } } = await container.inspect();
-        if (Status === "running" || Status === "restarting") {
-            try {
-                await container.stop();
-            }
-            catch (err) {
-                makes_1.Logger.error("DockerService.removeContainer", err.message);
-            }
-        }
-        try {
-            await container.remove();
-        }
-        catch (err) {
-            makes_1.Logger.error("DockerService.removeContainer: ", err.message);
-        }
+        await this.containerService.rm(name);
     }
     async buildImage(params) {
         const { tag, labels = {}, buildArgs = {}, context, src } = params;
-        const files = await makes_1.FS.readdirFiles(context, {
+        const fs = new core_1.FileSystem(context);
+        const files = await fs.readdirFiles("", {
             recursive: true
         });
         const stream = await this.docker.buildImage({
@@ -193,27 +163,13 @@ let DockerService = class DockerService extends core_1.DockerService {
             }, {}),
             dockerfile: src
         });
-        await (0, utils_1.followProgress)(stream);
+        await this.modemService.followProgress(stream);
     }
     async imageExists(tag) {
-        const image = this.docker.getImage(tag);
-        try {
-            await image.inspect();
-            return true;
-        }
-        catch (ignore) {
-            return false;
-        }
+        return this.imageService.exists(tag);
     }
     async imageRm(tag, force = false) {
-        const image = this.docker.getImage(tag);
-        const exists = await this.imageExists(tag);
-        if (!exists) {
-            return;
-        }
-        await image.remove({
-            force
-        });
+        await this.imageService.rm(tag, force);
     }
     async imageLs(options) {
         const { tag, reference, labels } = options || {};
@@ -241,12 +197,7 @@ let DockerService = class DockerService extends core_1.DockerService {
         });
     }
     async pullImage(tag) {
-        const exists = await this.imageExists(tag);
-        if (exists) {
-            return;
-        }
-        const stream = await this.docker.pull(tag);
-        await (0, utils_1.followProgress)(stream);
+        await this.imageService.pull(tag);
     }
     async attach(containerOrName) {
         let container = typeof containerOrName === "string"
@@ -277,54 +228,10 @@ let DockerService = class DockerService extends core_1.DockerService {
         return stream;
     }
     async attachStream(stream) {
-        if (process.stdin.isTTY) {
-            process.stdin.setRawMode(true);
-        }
-        process.stdin.resume();
-        process.stdin.setEncoding("utf8");
-        process.stdin.pipe(stream);
-        stream.setEncoding("utf8");
-        stream.pipe(process.stdout);
-        const onEnd = () => {
-            process.stdin.pause();
-            if (process.stdin.isTTY) {
-                process.stdin.setRawMode(false);
-            }
-            process.stdin.unpipe(stream);
-            stream.unpipe(process.stdout);
-        };
-        stream.on("end", onEnd);
-        stream.on("error", onEnd);
-        return stream;
+        return this.modemService.attachStream(stream);
     }
     async exec(nameOrContainer, options, _tty) {
-        const container = typeof nameOrContainer === "string"
-            ? await this.getContainer(nameOrContainer)
-            : nameOrContainer;
-        if (!container) {
-            return;
-        }
-        const { cmd = [], tty = false, user } = Array.isArray(options) ? {
-            cmd: options,
-            tty: _tty
-        } : options;
-        const exec = await container.exec({
-            AttachStdin: true,
-            AttachStdout: true,
-            AttachStderr: tty,
-            Tty: tty,
-            User: user,
-            Cmd: cmd
-        });
-        const stream = await exec.start({
-            hijack: true,
-            stdin: tty,
-            Tty: tty
-        });
-        if (tty) {
-            await this.attachStream(stream);
-        }
-        return stream;
+        return await this.containerService.exec(nameOrContainer, options, _tty);
     }
     async logs(containerOrName) {
         const container = typeof containerOrName === "string"
@@ -347,9 +254,15 @@ let DockerService = class DockerService extends core_1.DockerService {
         });
         return stream;
     }
+    async followProgress(stream) {
+        await this.modemService.followProgress(stream);
+    }
 };
 exports.DockerService = DockerService;
 exports.DockerService = DockerService = __decorate([
     (0, core_1.Injectable)("DOCKER_SERVICE"),
-    __metadata("design:paramtypes", [LogService_1.LogService])
+    __metadata("design:paramtypes", [ModemService_1.ModemService,
+        ContainerService_1.ContainerService,
+        ImageService_1.ImageService,
+        core_1.LogService])
 ], DockerService);

package/lib/modules/docker/services/ImageService.d.ts

@@ -0,0 +1,18 @@
+import type Docker from "dockerode";
+import { ModemService } from "./ModemService";
+type BuildParams = {
+    tag: string;
+    context: string;
+    dockerfile: string;
+    version: "1" | "2";
+};
+export declare class ImageService {
+    protected readonly modemService: ModemService;
+    constructor(modemService: ModemService);
+    get docker(): Docker;
+    build(params: BuildParams): Promise<void>;
+    exists(tag: string): Promise<boolean>;
+    pull(tag: string): Promise<void>;
+    rm(tag: string, force?: boolean): Promise<void>;
+}
+export {};

package/lib/modules/docker/services/ImageService.js

@@ -0,0 +1,68 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImageService = void 0;
+const core_1 = require("@wocker/core");
+const ModemService_1 = require("./ModemService");
+let ImageService = class ImageService {
+    constructor(modemService) {
+        this.modemService = modemService;
+    }
+    get docker() {
+        return this.modemService.docker;
+    }
+    async build(params) {
+        const { tag, context, dockerfile, version } = params;
+        const files = (new core_1.FileSystem(context)).readdir("", {
+            recursive: true
+        });
+        const stream = await this.docker.buildImage({
+            context,
+            src: files
+        }, {
+            t: tag,
+            dockerfile,
+            version
+        });
+        await this.modemService.followProgress(stream);
+    }
+    async exists(tag) {
+        const image = this.docker.getImage(tag);
+        try {
+            await image.inspect();
+            return true;
+        }
+        catch (err) {
+            return false;
+        }
+    }
+    async pull(tag) {
+        if (await this.exists(tag)) {
+            return;
+        }
+        const stream = await this.docker.pull(tag);
+        await this.modemService.followProgress(stream);
+    }
+    async rm(tag, force = false) {
+        if (!await this.exists(tag)) {
+            return;
+        }
+        const image = this.docker.getImage(tag);
+        await image.remove({
+            force
+        });
+    }
+};
+exports.ImageService = ImageService;
+exports.ImageService = ImageService = __decorate([
+    (0, core_1.Injectable)(),
+    __metadata("design:paramtypes", [ModemService_1.ModemService])
+], ImageService);

package/lib/modules/docker/services/ModemService.d.ts

@@ -0,0 +1,15 @@
+import { ModemService as CoreModemService } from "@wocker/core";
+import type Modem from "docker-modem";
+import type Docker from "dockerode";
+import { ProtoService } from "./ProtoService";
+export declare class ModemService extends CoreModemService {
+    protected readonly protoService: ProtoService;
+    protected _modem?: Modem;
+    protected _docker?: Docker;
+    protected record?: boolean;
+    constructor(protoService: ProtoService);
+    get modem(): Modem;
+    get docker(): Docker;
+    attachStream(stream: NodeJS.ReadWriteStream): Promise<NodeJS.ReadWriteStream>;
+    followProgress(stream: NodeJS.ReadableStream): Promise<void>;
+}