@wocker/ws 1.0.25 → 1.0.26

package/lib/modules/dns/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;
+};
+var DnsModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DnsModule = void 0;
+const core_1 = require("@wocker/core");
+const core_2 = require("../core");
+const docker_1 = require("../docker");
+const DnsController_1 = require("./controllers/DnsController");
+const DnsService_1 = require("./services/DnsService");
+let DnsModule = DnsModule_1 = class DnsModule {
+    static register() {
+        return {
+            module: DnsModule_1,
+            inject: [core_1.AppConfigService],
+            useFactory: (appConfigService) => {
+                if (!appConfigService.isExperimentalEnabled("dns")) {
+                    return {};
+                }
+                return {
+                    imports: [docker_1.DockerModule],
+                    controllers: [DnsController_1.DnsController],
+                    providers: [DnsService_1.DnsService]
+                };
+            }
+        };
+    }
+};
+exports.DnsModule = DnsModule;
+exports.DnsModule = DnsModule = DnsModule_1 = __decorate([
+    (0, core_1.Module)({
+        imports: [
+            core_2.CoreModule
+        ]
+    })
+], DnsModule);

package/lib/modules/dns/services/DnsService.d.ts

@@ -0,0 +1,10 @@
+import { DockerService } from "../../docker";
+export declare class DnsService {
+    protected readonly dockerService: DockerService;
+    protected imageName: string;
+    protected containerName: string;
+    constructor(dockerService: DockerService);
+    start(restart?: boolean, rebuild?: boolean): Promise<void>;
+    stop(): Promise<void>;
+    build(rebuild?: boolean): Promise<void>;
+}

package/lib/modules/dns/services/DnsService.js

@@ -0,0 +1,77 @@
+"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);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DnsService = void 0;
+const core_1 = require("@wocker/core");
+const path_1 = __importDefault(require("path"));
+const docker_1 = require("../../docker");
+const env_1 = require("../../../env");
+let DnsService = class DnsService {
+    constructor(dockerService) {
+        this.dockerService = dockerService;
+        this.imageName = "wocker-dns:0.0.1";
+        this.containerName = "wocker-dns";
+    }
+    async start(restart, rebuild) {
+        console.info("Starting DNS service...");
+        console.info("DNS service currently isn't working");
+        if (restart || rebuild) {
+            await this.dockerService.removeContainer(this.containerName);
+        }
+        await this.build(rebuild);
+        let container = await this.dockerService.getContainer(this.containerName);
+        const fs = new core_1.FileSystem(`${env_1.ROOT_DIR}/plugins/dns`);
+        if (!fs.exists("etc/dnsmasq.conf")) {
+            fs.writeFile("etc/dnsmasq.conf", "");
+        }
+        if (!container) {
+            container = await this.dockerService.createContainer({
+                name: this.containerName,
+                image: this.imageName,
+                volumes: [
+                    "/var/run/docker.sock.raw:/var/run/docker.sock:ro",
+                    "/var/run/docker.sock.raw:/tmp/docker.sock:ro",
+                    `${fs.path("app/Procfile")}:/app/Procfile`,
+                    `${fs.path("app/dnsmasq.conf.tmpl")}:/app/dnsmasq.conf.tmpl`,
+                    `${fs.path("etc/dnsmasq.conf")}:/etc/dnsmasq.conf`
+                ]
+            });
+        }
+        const { State: { Running } } = await container.inspect();
+        if (!Running) {
+            await container.start();
+        }
+    }
+    async stop() {
+        await this.dockerService.removeContainer(this.containerName);
+    }
+    async build(rebuild) {
+        if (await this.dockerService.imageExists(this.imageName)) {
+            if (!rebuild) {
+                return;
+            }
+            await this.dockerService.imageRm(this.imageName);
+        }
+        await this.dockerService.buildImage({
+            tag: this.imageName,
+            dockerfile: "./Dockerfile",
+            context: path_1.default.join(env_1.ROOT_DIR, "fixtures/dns")
+        });
+    }
+};
+exports.DnsService = DnsService;
+exports.DnsService = DnsService = __decorate([
+    (0, core_1.Injectable)(),
+    __metadata("design:paramtypes", [docker_1.DockerService])
+], DnsService);

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

@@ -27,6 +27,6 @@ export declare class ComposeService {
     exec(options: ExecOptions): Promise<void>;
     protected getConfig(context: string, composefile: string): ComposeConfig;
     protected getConfigAsString(context: string, composefile: string): string;
-    protected processChunk(chunk: Buffer<ArrayBuffer>, streamSource?: "stdout" | "stderr"): void;
+    protected processChunk(chunk: Buffer<ArrayBufferLike>, streamSource?: "stdout" | "stderr"): void;
 }
 export {};

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

@@ -82,8 +82,6 @@ let ComposeService = class ComposeService {
     }
     async exec(options) {
         const { service, args, context, composefile } = options;
-        const config = this.getConfig(context, composefile);
-        console.log(config);
         await compose.exec(service, args, {
             configAsString: this.getConfigAsString(context, composefile),
             callback: (chunk, streamSource) => this.processChunk(chunk, streamSource)

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

@@ -1,6 +1,6 @@
 import { LogService, DockerServiceParams as Params } from "@wocker/core";
-import type Docker from "dockerode";
 import { Duplex } from "stream";
+import type Docker from "dockerode";
 import type { Container } from "dockerode";
 import { ModemService } from "./ModemService";
 export declare class ContainerService {

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

@@ -67,7 +67,6 @@ let DockerService = class DockerService extends core_1.DockerService {
             User: user,
             Image: image,
             Hostname: name,
-            Domainname: name,
             Labels: {
                 ...projectId ? { projectId } : {}
             },

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

@@ -7,7 +7,6 @@ export declare class ModemService extends CoreModemService {
     protected readonly logService: LogService;
     protected _modem?: Modem;
     protected _docker?: Docker;
-    protected record?: boolean;
     constructor(protoService: ProtoService, logService: LogService);
     get modem(): Modem;
     get docker(): Docker;

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

@@ -18,7 +18,6 @@ let ModemService = class ModemService extends core_1.ModemService {
         super();
         this.protoService = protoService;
         this.logService = logService;
-        this.record = true;
     }
     get modem() {
         if (!this._modem) {

package/lib/modules/index.d.ts

@@ -1,6 +1,9 @@
 export * from "./core";
+export * from "./dns";
 export * from "./docker";
 export * from "./keystore";
+export * from "./package-manager";
+export * from "./plugin";
 export * from "./preset";
 export * from "./project";
 export * from "./proxy";

package/lib/modules/index.js

@@ -15,8 +15,11 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./core"), exports);
+__exportStar(require("./dns"), exports);
 __exportStar(require("./docker"), exports);
 __exportStar(require("./keystore"), exports);
+__exportStar(require("./package-manager"), exports);
+__exportStar(require("./plugin"), exports);
 __exportStar(require("./preset"), exports);
 __exportStar(require("./project"), exports);
 __exportStar(require("./proxy"), exports);

package/lib/modules/keystore/controllers/KeystoreController.d.ts

@@ -5,7 +5,4 @@ export declare class KeystoreController {
     protected readonly keystoreService: KeystoreService;
     constructor(appConfigService: AppConfigService, keystoreService: KeystoreService);
     init(provider?: string): Promise<void>;
-    add(name?: string, provider?: string): Promise<void>;
-    inspect(name?: string, provider?: string): Promise<string | undefined>;
-    delete(name?: string, provider?: string): Promise<void>;
 }

package/lib/modules/keystore/controllers/KeystoreController.js

@@ -35,68 +35,17 @@ let KeystoreController = class KeystoreController {
         this.appConfigService.config.keystore = provider;
         this.appConfigService.save();
     }
-    async add(name, provider) {
-        const value = await (0, utils_1.promptInput)({
-            message: "Secret value",
-            type: "password"
-        });
-        await this.keystoreService.provider(provider).set(name, value);
-    }
-    async inspect(name, provider) {
-        return this.keystoreService.provider(provider).get(name);
-    }
-    async delete(name, provider) {
-        await this.keystoreService.provider(provider).delete(name);
-    }
 };
 exports.KeystoreController = KeystoreController;
 __decorate([
     (0, core_1.Command)("keystore:init"),
-    __param(0, (0, core_1.Option)("provider", {
-        type: "string",
-        description: "Keystore provider name"
-    })),
+    (0, core_1.Description)("Initialize keystore"),
+    __param(0, (0, core_1.Option)("provider", "p")),
+    __param(0, (0, core_1.Description)("Keystore provider name")),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [String]),
     __metadata("design:returntype", Promise)
 ], KeystoreController.prototype, "init", null);
-__decorate([
-    (0, core_1.Command)("secret:create [name]"),
-    (0, core_1.Description)("Adds secret value to keystore"),
-    __param(0, (0, core_1.Param)("name")),
-    __param(1, (0, core_1.Option)("provider", {
-        alias: "p",
-        type: "string",
-        description: "Provider name"
-    })),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String, String]),
-    __metadata("design:returntype", Promise)
-], KeystoreController.prototype, "add", null);
-__decorate([
-    (0, core_1.Command)("secret:inspect [name]"),
-    __param(0, (0, core_1.Param)("name")),
-    __param(1, (0, core_1.Option)("provider", {
-        type: "string",
-        alias: "p"
-    })),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String, String]),
-    __metadata("design:returntype", Promise)
-], KeystoreController.prototype, "inspect", null);
-__decorate([
-    (0, core_1.Command)("secret:rm [name]"),
-    (0, core_1.Description)("Removes secret value from keystore"),
-    __param(0, (0, core_1.Param)("name")),
-    __param(1, (0, core_1.Option)("provider", {
-        type: "string",
-        alias: "p",
-        description: "Provider name"
-    })),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String, String]),
-    __metadata("design:returntype", Promise)
-], KeystoreController.prototype, "delete", null);
 exports.KeystoreController = KeystoreController = __decorate([
     (0, core_1.Controller)(),
     (0, core_1.Description)("Keystore commands"),

package/lib/modules/keystore/services/KeystoreService.d.ts

@@ -8,5 +8,6 @@ export declare class KeystoreService extends CoreKeystoreService {
     provider(name?: string): KeystoreProvider;
     get(keys: string | string[], byDefault?: string): Promise<string | undefined>;
     set(key: string, value: string): Promise<void>;
+    delete(key: string): Promise<void>;
     registerProvider(name: string, provider: KeystoreProvider): void;
 }

package/lib/modules/keystore/services/KeystoreService.js

@@ -56,6 +56,10 @@ let KeystoreService = class KeystoreService extends core_1.KeystoreService {
         const provider = this.provider();
         await provider.set(key, value);
     }
+    async delete(key) {
+        const provider = this.provider();
+        await provider.delete(key);
+    }
     registerProvider(name, provider) {
         if (this.providers.has(name)) {
             throw new Error(`Provider ${name} already registered`);

package/lib/modules/keystore/utils/createEncryptionKey.d.ts

@@ -1 +1 @@
-export declare const createEncryptionKey: (password: string, passwordHash: string) => Buffer<ArrayBufferLike>;
+export declare const createEncryptionKey: (password: string, passwordHash: string) => NonSharedBuffer;

package/lib/modules/package-manager/index.d.ts

@@ -0,0 +1,5 @@
+import { PackageManager } from "./service/PackageManager";
+import { RegistryService } from "./service/RegistryService";
+export declare class PackageManagerModule {
+}
+export { PackageManager, RegistryService };

package/lib/modules/package-manager/index.js

@@ -0,0 +1,33 @@
+"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.RegistryService = exports.PackageManager = exports.PackageManagerModule = void 0;
+const core_1 = require("@wocker/core");
+const core_2 = require("../core");
+const PackageManager_1 = require("./service/PackageManager");
+Object.defineProperty(exports, "PackageManager", { enumerable: true, get: function () { return PackageManager_1.PackageManager; } });
+const RegistryService_1 = require("./service/RegistryService");
+Object.defineProperty(exports, "RegistryService", { enumerable: true, get: function () { return RegistryService_1.RegistryService; } });
+let PackageManagerModule = class PackageManagerModule {
+};
+exports.PackageManagerModule = PackageManagerModule;
+exports.PackageManagerModule = PackageManagerModule = __decorate([
+    (0, core_1.Module)({
+        imports: [
+            core_2.CoreModule
+        ],
+        providers: [
+            PackageManager_1.PackageManager,
+            RegistryService_1.RegistryService
+        ],
+        exports: [
+            PackageManager_1.PackageManager,
+            RegistryService_1.RegistryService
+        ]
+    })
+], PackageManagerModule);

package/lib/modules/package-manager/providers/NpmProvider.d.ts

@@ -0,0 +1,7 @@
+import { PackageManagerProvider } from "../types/PackageManagerProvider";
+import { Package } from "../types/Package";
+export declare class NpmProvider extends PackageManagerProvider {
+    getPackages(): Promise<Package[]>;
+    install(name: string, version?: string): Promise<void>;
+    uninstall(name: string): Promise<void>;
+}

package/lib/modules/package-manager/providers/NpmProvider.js

@@ -0,0 +1,39 @@
+"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.NpmProvider = void 0;
+const core_1 = require("@wocker/core");
+const PackageManagerProvider_1 = require("../types/PackageManagerProvider");
+const utils_1 = require("../../../utils");
+let NpmProvider = class NpmProvider extends PackageManagerProvider_1.PackageManagerProvider {
+    async getPackages() {
+        const res = await (0, utils_1.exec)("npm ls -g --json");
+        const packages = [], { dependencies } = JSON.parse(res);
+        for (const name in dependencies) {
+            packages.push({
+                name: name,
+                version: dependencies[name].version
+            });
+        }
+        return packages;
+    }
+    async install(name, version) {
+        const command = `npm install -g ${version ? `${name}@${version}` : name}`;
+        console.info(`> ${command}`);
+        await (0, utils_1.exec)(command);
+    }
+    async uninstall(name) {
+        const command = `npm uninstall -g ${name}`;
+        console.info(`> ${command}`);
+        await (0, utils_1.exec)(command);
+    }
+};
+exports.NpmProvider = NpmProvider;
+exports.NpmProvider = NpmProvider = __decorate([
+    (0, core_1.Injectable)()
+], NpmProvider);

package/lib/modules/package-manager/providers/PnpmProvider.d.ts

@@ -0,0 +1,7 @@
+import { PackageManagerProvider } from "../types/PackageManagerProvider";
+import { Package } from "../types/Package";
+export declare class PnpmProvider extends PackageManagerProvider {
+    getPackages(): Promise<Package[]>;
+    install(name: string, version?: string): Promise<void>;
+    uninstall(name: string): Promise<void>;
+}

package/lib/modules/package-manager/providers/PnpmProvider.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PnpmProvider = void 0;
+const PackageManagerProvider_1 = require("../types/PackageManagerProvider");
+const utils_1 = require("../../../utils");
+class PnpmProvider extends PackageManagerProvider_1.PackageManagerProvider {
+    async getPackages() {
+        const res = await (0, utils_1.exec)("pnpm ls -g --json"), data = JSON.parse(res), dependencies = Array.isArray(data) ? data[0]?.dependencies : data.dependencies, packages = [];
+        if (dependencies) {
+            for (const name in dependencies) {
+                packages.push({
+                    name,
+                    version: dependencies[name].version
+                });
+            }
+        }
+        return packages;
+    }
+    async install(name, version) {
+        const command = `pnpm add -g ${version ? `${name}@${version}` : name}`;
+        console.info(`> ${command}`);
+        await (0, utils_1.exec)(command);
+    }
+    async uninstall(name) {
+        const command = `pnpm remove -g ${name}`;
+        console.info(`> ${command}`);
+        await (0, utils_1.exec)(command);
+    }
+}
+exports.PnpmProvider = PnpmProvider;

package/lib/modules/package-manager/providers/YarnProvider.d.ts

@@ -0,0 +1,7 @@
+import { PackageManagerProvider } from "../types/PackageManagerProvider";
+import { Package } from "../types/Package";
+export declare class YarnProvider extends PackageManagerProvider {
+    getPackages(): Promise<Package[]>;
+    install(name: string, version?: string): Promise<void>;
+    uninstall(name: string): Promise<void>;
+}

package/lib/modules/package-manager/providers/YarnProvider.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.YarnProvider = void 0;
+const PackageManagerProvider_1 = require("../types/PackageManagerProvider");
+const utils_1 = require("../../../utils");
+class YarnProvider extends PackageManagerProvider_1.PackageManagerProvider {
+    async getPackages() {
+        const res = await (0, utils_1.exec)("yarn --cwd `yarn global dir` list --json --depth=0"), three = JSON.parse(res), packages = [];
+        for (const item of three.data.trees) {
+            const [, name, version] = /^(.*)@(.*)$/.exec(item.name);
+            packages.push({
+                name,
+                version
+            });
+        }
+        return packages;
+    }
+    async install(name, version) {
+        const command = `yarn global add ${version ? `${name}@${version}` : name}`;
+        console.info(`> ${command}`);
+        await (0, utils_1.exec)(command);
+    }
+    async uninstall(name) {
+        const command = `yarn global remove ${name}`;
+        console.info(`> ${command}`);
+        await (0, utils_1.exec)(command);
+    }
+}
+exports.YarnProvider = YarnProvider;

package/lib/modules/package-manager/service/PackageManager.d.ts

@@ -0,0 +1,10 @@
+import { AppConfigService } from "@wocker/core";
+import { PackageManagerProvider } from "../types/PackageManagerProvider";
+export declare class PackageManager {
+    protected readonly appConfigService: AppConfigService;
+    constructor(appConfigService: AppConfigService);
+    getManager(): Promise<PackageManagerProvider>;
+    getPackages(global?: boolean): Promise<import("../types/Package").Package[]>;
+    install(name: string, version?: string): Promise<void>;
+    uninstall(name: string): Promise<void>;
+}

package/lib/modules/package-manager/service/PackageManager.js

@@ -0,0 +1,70 @@
+"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.PackageManager = void 0;
+const core_1 = require("@wocker/core");
+const utils_1 = require("@wocker/utils");
+const NpmProvider_1 = require("../providers/NpmProvider");
+const PnpmProvider_1 = require("../providers/PnpmProvider");
+const YarnProvider_1 = require("../providers/YarnProvider");
+let PackageManager = class PackageManager {
+    constructor(appConfigService) {
+        this.appConfigService = appConfigService;
+    }
+    async getManager() {
+        if (!this.appConfigService.config.pm) {
+            this.appConfigService.config.pm = await (0, utils_1.promptSelect)({
+                label: "Package manager:",
+                options: [
+                    {
+                        label: "NPM",
+                        value: "npm"
+                    },
+                    {
+                        label: "PNPM",
+                        value: "pnpm"
+                    },
+                    {
+                        label: "YARN",
+                        value: "yarn"
+                    }
+                ],
+                required: true
+            });
+            this.appConfigService.save();
+        }
+        switch (this.appConfigService.config.pm) {
+            case "npm":
+                return new NpmProvider_1.NpmProvider();
+            case "pnpm":
+                return new PnpmProvider_1.PnpmProvider();
+            case "yarn":
+                return new YarnProvider_1.YarnProvider();
+        }
+    }
+    async getPackages(global) {
+        const pm = await this.getManager();
+        return pm.getPackages(global);
+    }
+    async install(name, version) {
+        const pm = await this.getManager();
+        await pm.install(name, version);
+    }
+    async uninstall(name) {
+        const pm = await this.getManager();
+        await pm.uninstall(name);
+    }
+};
+exports.PackageManager = PackageManager;
+exports.PackageManager = PackageManager = __decorate([
+    (0, core_1.Injectable)("PACKAGE_MANAGER_SERVICE"),
+    __metadata("design:paramtypes", [core_1.AppConfigService])
+], PackageManager);

package/lib/modules/package-manager/service/RegistryService.d.ts

@@ -0,0 +1,4 @@
+import { PackageInfo } from "../types/PackageInfo";
+export declare class RegistryService {
+    getPackageInfo(name: string): Promise<PackageInfo>;
+}

package/lib/{services/NpmService.js → modules/package-manager/service/RegistryService.js}

@@ -6,11 +6,10 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.NpmService = void 0;
+exports.RegistryService = void 0;
 const core_1 = require("@wocker/core");
-const makes_1 = require("../makes");
-const utils_1 = require("../utils");
-let NpmService = class NpmService {
+const makes_1 = require("../../../makes");
+let RegistryService = class RegistryService {
     async getPackageInfo(name) {
         const res = await makes_1.Http.get("https://registry.npmjs.org")
             .send(name);
@@ -22,12 +21,8 @@ let NpmService = class NpmService {
         }
         return res.data;
     }
-    async install(name, version) {
-        console.info(`npm install -g ${version ? `${name}@${version}` : name}`);
-        await (0, utils_1.exec)(`npm install -g ${version ? `${name}@${version}` : name}`);
-    }
 };
-exports.NpmService = NpmService;
-exports.NpmService = NpmService = __decorate([
+exports.RegistryService = RegistryService;
+exports.RegistryService = RegistryService = __decorate([
     (0, core_1.Injectable)()
-], NpmService);
+], RegistryService);

package/lib/modules/package-manager/types/Package.d.ts

@@ -0,0 +1,4 @@
+export type Package = {
+    name: string;
+    version: string;
+};

package/lib/modules/package-manager/types/PackageInfo.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/modules/package-manager/types/PackageManagerProvider.d.ts

@@ -0,0 +1,6 @@
+import { Package } from "./Package";
+export declare abstract class PackageManagerProvider {
+    abstract getPackages(global?: boolean): Promise<Package[]>;
+    abstract install(name: string, version?: string): Promise<void>;
+    abstract uninstall(name: string): Promise<void>;
+}

package/lib/modules/package-manager/types/PackageManagerProvider.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PackageManagerProvider = void 0;
+class PackageManagerProvider {
+}
+exports.PackageManagerProvider = PackageManagerProvider;

package/lib/{controllers → modules/plugin/controllers}/PluginController.d.ts

@@ -5,8 +5,8 @@ export declare class PluginController {
     protected readonly pluginService: PluginService;
     constructor(appConfigService: AppConfigService, pluginService: PluginService);
     list(): Promise<string>;
-    add(addName: string, beta?: boolean): Promise<void>;
-    remove(removeName: string): Promise<void>;
+    add(names: string[]): Promise<void>;
+    remove(names: string[]): Promise<void>;
     update(): Promise<void>;
     getInstalledPlugins(): string[];
 }