@lordbex/thelounge 4.4.3-blowfish

package/dist/server/clientManager.js

@@ -0,0 +1,220 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const lodash_1 = __importDefault(require("lodash"));
+const chalk_1 = __importDefault(require("chalk"));
+const crypto_1 = __importDefault(require("crypto"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const auth_1 = __importDefault(require("./plugins/auth"));
+const client_1 = __importDefault(require("./client"));
+const config_1 = __importDefault(require("./config"));
+const webpush_1 = __importDefault(require("./plugins/webpush"));
+const log_1 = __importDefault(require("./log"));
+class ClientManager {
+    clients;
+    sockets;
+    identHandler;
+    webPush;
+    constructor() {
+        this.clients = [];
+    }
+    init(identHandler, sockets) {
+        this.sockets = sockets;
+        this.identHandler = identHandler;
+        this.webPush = new webpush_1.default();
+        if (!config_1.default.values.public) {
+            this.loadUsers();
+            // LDAP does not have user commands, and users are dynamically
+            // created upon logon, so we don't need to watch for new files
+            if (!config_1.default.values.ldap.enable) {
+                this.autoloadUsers();
+            }
+        }
+    }
+    findClient(name) {
+        name = name.toLowerCase();
+        return this.clients.find((u) => u.name.toLowerCase() === name);
+    }
+    loadUsers() {
+        let users = this.getUsers();
+        if (users.length === 0) {
+            log_1.default.info(`There are currently no users. Create one with ${chalk_1.default.bold("thelounge add <name>")}.`);
+            return;
+        }
+        const alreadySeenUsers = new Set();
+        users = users.filter((user) => {
+            user = user.toLowerCase();
+            if (alreadySeenUsers.has(user)) {
+                log_1.default.error(`There is more than one user named "${chalk_1.default.bold(user)}". Usernames are now case insensitive, duplicate users will not load.`);
+                return false;
+            }
+            alreadySeenUsers.add(user);
+            return true;
+        });
+        // This callback is used by Auth plugins to load users they deem acceptable
+        const callbackLoadUser = (user) => {
+            this.loadUser(user);
+        };
+        if (!auth_1.default.loadUsers(users, callbackLoadUser)) {
+            // Fallback to loading all users
+            users.forEach((name) => this.loadUser(name));
+        }
+    }
+    autoloadUsers() {
+        fs_1.default.watch(config_1.default.getUsersPath(), lodash_1.default.debounce(() => {
+            const loaded = this.clients.map((c) => c.name);
+            const updatedUsers = this.getUsers();
+            if (updatedUsers.length === 0) {
+                log_1.default.info(`There are currently no users. Create one with ${chalk_1.default.bold("thelounge add <name>")}.`);
+            }
+            // Reload all users. Existing users will only have their passwords reloaded.
+            updatedUsers.forEach((name) => this.loadUser(name));
+            // Existing users removed since last time users were loaded
+            lodash_1.default.difference(loaded, updatedUsers).forEach((name) => {
+                const client = lodash_1.default.find(this.clients, { name });
+                if (client) {
+                    client.quit(true);
+                    this.clients = lodash_1.default.without(this.clients, client);
+                    log_1.default.info(`User ${chalk_1.default.bold(name)} disconnected and removed.`);
+                }
+            });
+        }, 1000, { maxWait: 10000 }));
+    }
+    loadUser(name) {
+        const userConfig = this.readUserConfig(name);
+        if (!userConfig) {
+            return;
+        }
+        let client = this.findClient(name);
+        if (client) {
+            if (userConfig.password !== client.config.password) {
+                /**
+                 * If we happen to reload an existing client, make super duper sure we
+                 * have their latest password. We're not replacing the entire config
+                 * object, because that could have undesired consequences.
+                 *
+                 * @see https://github.com/thelounge/thelounge/issues/598
+                 */
+                client.config.password = userConfig.password;
+                log_1.default.info(`Password for user ${chalk_1.default.bold(name)} was reset.`);
+            }
+        }
+        else {
+            client = new client_1.default(this, name, userConfig);
+            client.connect();
+            this.clients.push(client);
+        }
+        return client;
+    }
+    getUsers = function () {
+        if (!fs_1.default.existsSync(config_1.default.getUsersPath())) {
+            return [];
+        }
+        return fs_1.default
+            .readdirSync(config_1.default.getUsersPath())
+            .filter((file) => file.endsWith(".json"))
+            .map((file) => file.slice(0, -5));
+    };
+    addUser(name, password, enableLog) {
+        if (path_1.default.basename(name) !== name) {
+            throw new Error(`${name} is an invalid username.`);
+        }
+        const userPath = config_1.default.getUserConfigPath(name);
+        if (fs_1.default.existsSync(userPath)) {
+            log_1.default.error(`User ${chalk_1.default.green(name)} already exists.`);
+            return false;
+        }
+        const user = {
+            password: password || "",
+            log: enableLog,
+        };
+        try {
+            fs_1.default.writeFileSync(userPath, JSON.stringify(user, null, "\t"), {
+                mode: 0o600,
+            });
+        }
+        catch (e) {
+            log_1.default.error(`Failed to create user ${chalk_1.default.green(name)} (${e})`);
+            throw e;
+        }
+        try {
+            const userFolderStat = fs_1.default.statSync(config_1.default.getUsersPath());
+            const userFileStat = fs_1.default.statSync(userPath);
+            if (userFolderStat &&
+                userFileStat &&
+                (userFolderStat.uid !== userFileStat.uid || userFolderStat.gid !== userFileStat.gid)) {
+                log_1.default.warn(`User ${chalk_1.default.green(name)} has been created, but with a different uid (or gid) than expected.`);
+                log_1.default.warn("The file owner has been changed to the expected user. " +
+                    "To prevent any issues, please run thelounge commands " +
+                    "as the correct user that owns the config folder.");
+                log_1.default.warn("See https://thelounge.chat/docs/usage#using-the-correct-system-user for more information.");
+                fs_1.default.chownSync(userPath, userFolderStat.uid, userFolderStat.gid);
+            }
+        }
+        catch (e) {
+            // We're simply verifying file owner as a safe guard for users
+            // that run `thelounge add` as root, so we don't care if it fails
+        }
+        return true;
+    }
+    getDataToSave(client) {
+        const json = Object.assign({}, client.config, {
+            networks: client.networks.map((n) => n.export()),
+        });
+        const newUser = JSON.stringify(json, null, "\t");
+        const newHash = crypto_1.default.createHash("sha256").update(newUser).digest("hex");
+        return { newUser, newHash };
+    }
+    saveUser(client, callback) {
+        const { newUser, newHash } = this.getDataToSave(client);
+        // Do not write to disk if the exported data hasn't actually changed
+        if (client.fileHash === newHash) {
+            return;
+        }
+        const pathReal = config_1.default.getUserConfigPath(client.name);
+        const pathTemp = pathReal + ".tmp";
+        try {
+            // Write to a temp file first, in case the write fails
+            // we do not lose the original file (for example when disk is full)
+            fs_1.default.writeFileSync(pathTemp, newUser, {
+                mode: 0o600,
+            });
+            fs_1.default.renameSync(pathTemp, pathReal);
+            return callback ? callback() : true;
+        }
+        catch (e) {
+            log_1.default.error(`Failed to update user ${chalk_1.default.green(client.name)} (${e})`);
+            if (callback) {
+                callback(e);
+            }
+        }
+    }
+    removeUser(name) {
+        const userPath = config_1.default.getUserConfigPath(name);
+        if (!fs_1.default.existsSync(userPath)) {
+            log_1.default.error(`Tried to remove non-existing user ${chalk_1.default.green(name)}.`);
+            return false;
+        }
+        fs_1.default.unlinkSync(userPath);
+        return true;
+    }
+    readUserConfig(name) {
+        const userPath = config_1.default.getUserConfigPath(name);
+        if (!fs_1.default.existsSync(userPath)) {
+            log_1.default.error(`Tried to read non-existing user ${chalk_1.default.green(name)}`);
+            return false;
+        }
+        try {
+            const data = fs_1.default.readFileSync(userPath, "utf-8");
+            return JSON.parse(data);
+        }
+        catch (e) {
+            log_1.default.error(`Failed to read user ${chalk_1.default.bold(name)}: ${e}`);
+        }
+        return false;
+    }
+}
+exports.default = ClientManager;

package/dist/server/command-line/index.js

@@ -0,0 +1,85 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/no-var-requires */
+const log_1 = __importDefault(require("../log"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+const commander_1 = require("commander");
+const helper_1 = __importDefault(require("../helper"));
+const config_1 = __importDefault(require("../config"));
+const utils_1 = __importDefault(require("./utils"));
+const program = new commander_1.Command("thelounge");
+program
+    .version(helper_1.default.getVersion(), "-v, --version")
+    .option("-c, --config <key=value>", "override entries of the configuration file, must be specified for each entry that needs to be overriden", utils_1.default.parseConfigOptions)
+    .on("--help", utils_1.default.extraHelp);
+// Parse options from `argv` returning `argv` void of these options.
+const argvWithoutOptions = program.parseOptions(process.argv);
+config_1.default.setHome(process.env.THELOUNGE_HOME || utils_1.default.defaultHome());
+// Check config file owner and warn if we're running under a different user
+try {
+    verifyFileOwner();
+}
+catch (e) {
+    // We do not care about failures of these checks
+    // fs.statSync will throw if config.js does not exist (e.g. first run)
+}
+// Create packages/package.json
+createPackagesFolder();
+// Merge config key-values passed as CLI options into the main config
+config_1.default.merge(program.opts().config);
+program.addCommand(require("./start").default);
+program.addCommand(require("./install").default);
+program.addCommand(require("./uninstall").default);
+program.addCommand(require("./upgrade").default);
+program.addCommand(require("./outdated").default);
+program.addCommand(require("./storage").default);
+if (!config_1.default.values.public) {
+    require("./users").default.forEach((command) => {
+        if (command) {
+            program.addCommand(command);
+        }
+    });
+}
+// `parse` expects to be passed `process.argv`, but we need to remove to give it
+// a version of `argv` that does not contain options already parsed by
+// `parseOptions` above.
+// This is done by giving it the updated `argv` that `parseOptions` returned,
+// except it returns an object with `operands`/`unknown`, so we need to concat them.
+// See https://github.com/tj/commander.js/blob/fefda77f463292/index.js#L686-L763
+program.parse(argvWithoutOptions.operands.concat(argvWithoutOptions.unknown));
+function createPackagesFolder() {
+    const packagesPath = config_1.default.getPackagesPath();
+    const packagesConfig = path_1.default.join(packagesPath, "package.json");
+    // Create node_modules folder, otherwise yarn will start walking upwards to find one
+    fs_1.default.mkdirSync(path_1.default.join(packagesPath, "node_modules"), { recursive: true });
+    // Create package.json with private set to true, if it doesn't exist already
+    if (!fs_1.default.existsSync(packagesConfig)) {
+        fs_1.default.writeFileSync(packagesConfig, JSON.stringify({
+            private: true,
+            description: "Packages for The Lounge. Use `thelounge install <package>` command to add a package.",
+            dependencies: {},
+        }, null, "\t"));
+    }
+}
+function verifyFileOwner() {
+    if (!process.getuid) {
+        return;
+    }
+    const uid = process.getuid();
+    if (uid === 0) {
+        log_1.default.warn(`You are currently running The Lounge as root. ${chalk_1.default.bold.red("We highly discourage running as root!")}`);
+    }
+    const configStat = fs_1.default.statSync(path_1.default.join(config_1.default.getHomePath(), "config.js"));
+    if (configStat && configStat.uid !== uid) {
+        log_1.default.warn("Config file owner does not match the user you are currently running The Lounge as.");
+        log_1.default.warn("To prevent any issues, please run thelounge commands " +
+            "as the correct user that owns the config folder.");
+        log_1.default.warn("See https://thelounge.chat/docs/usage#using-the-correct-system-user for more information.");
+    }
+}
+exports.default = program;

package/dist/server/command-line/install.js

@@ -0,0 +1,123 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/restrict-template-expressions */
+const log_1 = __importDefault(require("../log"));
+const chalk_1 = __importDefault(require("chalk"));
+const semver_1 = __importDefault(require("semver"));
+const helper_1 = __importDefault(require("../helper"));
+const config_1 = __importDefault(require("../config"));
+const utils_1 = __importDefault(require("./utils"));
+const commander_1 = require("commander");
+const program = new commander_1.Command("install");
+program
+    .argument("<package>", "package to install. Use `file:$path_to_package_dir` to install a local package")
+    .description("Install a theme or a package")
+    .on("--help", utils_1.default.extraHelp)
+    .action(async function (packageName) {
+    const fs = await Promise.resolve().then(() => __importStar(require("fs")));
+    const fspromises = fs.promises;
+    const path = await Promise.resolve().then(() => __importStar(require("path")));
+    const packageJson = await Promise.resolve().then(() => __importStar(require("package-json")));
+    if (!fs.existsSync(config_1.default.getConfigPath())) {
+        log_1.default.error(`${config_1.default.getConfigPath()} does not exist.`);
+        return;
+    }
+    log_1.default.info("Retrieving information about the package...");
+    // TODO: type
+    let readFile = null;
+    let isLocalFile = false;
+    if (packageName.startsWith("file:")) {
+        isLocalFile = true;
+        // our yarn invocation sets $HOME to the cachedir, so we must expand ~ now
+        // else the path will be invalid when npm expands it.
+        packageName = expandTildeInLocalPath(packageName);
+        readFile = fspromises
+            .readFile(path.join(packageName.substring("file:".length), "package.json"), "utf-8")
+            .then((data) => JSON.parse(data));
+    }
+    else {
+        // properly split scoped and non-scoped npm packages
+        // into their name and version
+        let packageVersion = "latest";
+        const atIndex = packageName.indexOf("@", 1);
+        if (atIndex !== -1) {
+            packageVersion = packageName.slice(atIndex + 1);
+            packageName = packageName.slice(0, atIndex);
+        }
+        readFile = packageJson.default(packageName, {
+            fullMetadata: true,
+            version: packageVersion,
+        });
+    }
+    if (!readFile) {
+        // no-op, error should've been thrown before this point
+        return;
+    }
+    readFile
+        .then((json) => {
+        const humanVersion = isLocalFile ? packageName : `${json.name} v${json.version}`;
+        if (!("thelounge" in json)) {
+            log_1.default.error(`${chalk_1.default.red(humanVersion)} does not have The Lounge metadata.`);
+            process.exit(1);
+        }
+        if (json.thelounge.supports &&
+            !semver_1.default.satisfies(helper_1.default.getVersionNumber(), json.thelounge.supports, {
+                includePrerelease: true,
+            })) {
+            log_1.default.error(`${chalk_1.default.red(humanVersion)} does not support The Lounge v${helper_1.default.getVersionNumber()}. Supported version(s): ${json.thelounge.supports}`);
+            process.exit(2);
+        }
+        log_1.default.info(`Installing ${chalk_1.default.green(humanVersion)}...`);
+        const yarnVersion = isLocalFile ? packageName : `${json.name}@${json.version}`;
+        return utils_1.default.executeYarnCommand("add", "--exact", yarnVersion)
+            .then(() => {
+            log_1.default.info(`${chalk_1.default.green(humanVersion)} has been successfully installed.`);
+            if (isLocalFile) {
+                // yarn v1 is buggy if a local filepath is used and doesn't update
+                // the lockfile properly. We need to run an install in that case
+                // even though that's supposed to be done by the add subcommand
+                return utils_1.default.executeYarnCommand("install").catch((err) => {
+                    throw `Failed to update lockfile after package install ${err}`;
+                });
+            }
+        })
+            .catch((code) => {
+            throw `Failed to install ${chalk_1.default.red(humanVersion)}. Exit code: ${code}`;
+        });
+    })
+        .catch((e) => {
+        log_1.default.error(`${e}`);
+        process.exit(1);
+    });
+});
+function expandTildeInLocalPath(packageName) {
+    const path = packageName.substring("file:".length);
+    return "file:" + helper_1.default.expandHome(path);
+}
+exports.default = program;

package/dist/server/command-line/outdated.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const utils_1 = __importDefault(require("./utils"));
+const packages_1 = __importDefault(require("../plugins/packages"));
+const log_1 = __importDefault(require("../log"));
+const program = new commander_1.Command("outdated");
+program
+    .description("Check for any outdated packages")
+    .on("--help", utils_1.default.extraHelp)
+    .action(async () => {
+    log_1.default.info("Checking for outdated packages");
+    await packages_1.default
+        .outdated(0)
+        .then((outdated) => {
+        if (outdated) {
+            log_1.default.info("There are outdated packages");
+        }
+        else {
+            log_1.default.info("No outdated packages");
+        }
+    })
+        .catch(() => {
+        log_1.default.error("Error finding outdated packages.");
+    });
+});
+exports.default = program;

package/dist/server/command-line/start.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const log_1 = __importDefault(require("../log"));
+const chalk_1 = __importDefault(require("chalk"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const commander_1 = require("commander");
+const config_1 = __importDefault(require("../config"));
+const utils_1 = __importDefault(require("./utils"));
+const program = new commander_1.Command("start");
+program
+    .description("Start the server")
+    .option("--dev", "Development mode with hot module reloading")
+    .on("--help", utils_1.default.extraHelp)
+    .action(function (options) {
+    initalizeConfig();
+    const newLocal = "../server";
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const server = require(newLocal);
+    server.default(options);
+});
+function initalizeConfig() {
+    if (!fs_1.default.existsSync(config_1.default.getConfigPath())) {
+        fs_1.default.mkdirSync(config_1.default.getHomePath(), { recursive: true });
+        fs_1.default.chmodSync(config_1.default.getHomePath(), "0700");
+        fs_1.default.copyFileSync(path_1.default.resolve(path_1.default.join(__dirname, "..", "..", "defaults", "config.js")), config_1.default.getConfigPath());
+        log_1.default.info(`Configuration file created at ${chalk_1.default.green(config_1.default.getConfigPath())}.`);
+    }
+    fs_1.default.mkdirSync(config_1.default.getUsersPath(), { recursive: true, mode: 0o700 });
+}
+exports.default = program;

package/dist/server/command-line/storage.js

@@ -0,0 +1,103 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const log_1 = __importDefault(require("../log"));
+const commander_1 = require("commander");
+const clientManager_1 = __importDefault(require("../clientManager"));
+const utils_1 = __importDefault(require("./utils"));
+const sqlite_1 = __importDefault(require("../plugins/messageStorage/sqlite"));
+const storageCleaner_1 = require("../storageCleaner");
+const program = new commander_1.Command("storage").description("various utilities related to the message storage");
+program
+    .command("migrate")
+    .argument("[username]", "migrate a specific user only, all if not provided")
+    .description("Migrate message storage where needed")
+    .on("--help", utils_1.default.extraHelp)
+    .action(function (user) {
+    runMigrations(user).catch((err) => {
+        log_1.default.error(err.toString());
+        process.exit(1);
+    });
+});
+program
+    .command("clean")
+    .argument("[user]", "clean messages for a specific user only, all if not provided")
+    .description("Delete messages from the DB based on the storage policy")
+    .on("--help", utils_1.default.extraHelp)
+    .action(function (user) {
+    runCleaning(user).catch((err) => {
+        log_1.default.error(err.toString());
+        process.exit(1);
+    });
+});
+async function runMigrations(user) {
+    const manager = new clientManager_1.default();
+    const users = manager.getUsers();
+    if (user) {
+        if (!users.includes(user)) {
+            throw new Error(`invalid user ${user}`);
+        }
+        return migrateUser(manager, user);
+    }
+    for (const name of users) {
+        await migrateUser(manager, name);
+        // if any migration fails we blow up,
+        // chances are the rest won't complete either
+    }
+}
+// runs sqlite migrations for a user, which must exist
+async function migrateUser(manager, user) {
+    log_1.default.info("handling user", user);
+    if (!isUserLogEnabled(manager, user)) {
+        log_1.default.info("logging disabled for user", user, ". Skipping");
+        return;
+    }
+    const sqlite = new sqlite_1.default(user);
+    await sqlite.enable(); // enable runs migrations
+    await sqlite.close();
+    log_1.default.info("user", user, "migrated successfully");
+}
+function isUserLogEnabled(manager, user) {
+    const conf = manager.readUserConfig(user);
+    if (!conf) {
+        log_1.default.error("Could not open user configuration of", user);
+        return false;
+    }
+    return conf.log;
+}
+async function runCleaning(user) {
+    const manager = new clientManager_1.default();
+    const users = manager.getUsers();
+    if (user) {
+        if (!users.includes(user)) {
+            throw new Error(`invalid user ${user}`);
+        }
+        return cleanUser(manager, user);
+    }
+    for (const name of users) {
+        await cleanUser(manager, name);
+        // if any migration fails we blow up,
+        // chances are the rest won't complete either
+    }
+}
+async function cleanUser(manager, user) {
+    log_1.default.info("handling user", user);
+    if (!isUserLogEnabled(manager, user)) {
+        log_1.default.info("logging disabled for user", user, ". Skipping");
+        return;
+    }
+    const sqlite = new sqlite_1.default(user);
+    await sqlite.enable();
+    const cleaner = new storageCleaner_1.StorageCleaner(sqlite);
+    const num_deleted = await cleaner.runDeletesNoLimit();
+    log_1.default.info(`deleted ${num_deleted} messages`);
+    log_1.default.info("running a vacuum now, this might take a while");
+    if (num_deleted > 0) {
+        await sqlite.vacuum();
+    }
+    await sqlite.close();
+    log_1.default.info(`cleaning messages for ${user} has been successful`);
+}
+exports.default = program;

package/dist/server/command-line/uninstall.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const log_1 = __importDefault(require("../log"));
+const chalk_1 = __importDefault(require("chalk"));
+const commander_1 = require("commander");
+const config_1 = __importDefault(require("../config"));
+const utils_1 = __importDefault(require("./utils"));
+const program = new commander_1.Command("uninstall");
+program
+    .argument("<package>", "The package to uninstall")
+    .description("Uninstall a theme or a package")
+    .on("--help", utils_1.default.extraHelp)
+    .action(async function (packageName) {
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const fs = require("fs").promises;
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const path = require("path");
+    const packagesConfig = path.join(config_1.default.getPackagesPath(), "package.json");
+    // const packages = JSON.parse(fs.readFileSync(packagesConfig, "utf-8"));
+    const packages = JSON.parse(await fs.readFile(packagesConfig, "utf-8"));
+    if (!packages.dependencies ||
+        !Object.prototype.hasOwnProperty.call(packages.dependencies, packageName)) {
+        log_1.default.warn(`${chalk_1.default.green(packageName)} is not installed.`);
+        process.exit(1);
+    }
+    log_1.default.info(`Uninstalling ${chalk_1.default.green(packageName)}...`);
+    try {
+        await utils_1.default.executeYarnCommand("remove", packageName);
+        log_1.default.info(`${chalk_1.default.green(packageName)} has been successfully uninstalled.`);
+    }
+    catch (code_1) {
+        // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+        log_1.default.error(`Failed to uninstall ${chalk_1.default.green(packageName)}. Exit code: ${code_1}`);
+        process.exit(1);
+    }
+});
+exports.default = program;