@hurshb50/setup-ubuntu 0.0.1 → 0.0.3

package/distribution/setup-ubuntu.mjs

@@ -1,8 +1,641 @@
 #!/usr/bin/env node
 import { program } from "@commander-js/extra-typings";
+import os from "os";
+import path from "path";
+import styles from "ansi-styles";
+import escapes from "ansi-escapes";
+import { setTimeout } from "timers/promises";
+import { stdout } from "process";
+import fs from "fs/promises";
+import { execa } from "execa";
+//#region package.json
+var name = "@hurshb50/setup-ubuntu";
+var version = "0.0.2";
+//#endregion
+//#region source/modules/logger/logger.ts
+var Logger = class Logger {
+	status;
+	tasks;
+	tick;
+	static check = "✔";
+	static dots = [
+		"⠋",
+		"⠙",
+		"⠹",
+		"⠸",
+		"⠼",
+		"⠴",
+		"⠦",
+		"⠧",
+		"⠇",
+		"⠏"
+	];
+	static defaultColumns = 150;
+	constructor() {
+		this.status = "idle";
+		this.tasks = [];
+		this.tick = 0;
+	}
+	add(task) {
+		this.tasks.push(task);
+	}
+	start() {
+		if (this.status !== "idle") throw new Error(`Cannot start task logger when status is '${this.status}'.`);
+		this.status = "in-progress";
+		this.loop();
+	}
+	stop() {
+		if (this.status !== "in-progress") throw new Error(`Cannot start task logger when status is '${this.status}'.`);
+		this.status = "done";
+	}
+	async loop() {
+		const minimumIntervalMilliSeconds = 80;
+		this.newline();
+		this.banner("Ubuntu Setup");
+		this.newline();
+		while (this.status === "in-progress") {
+			const start = performance.now();
+			this.write();
+			const remainingTime = minimumIntervalMilliSeconds - (performance.now() - start);
+			await setTimeout(remainingTime);
+			this.tick += 1;
+		}
+		this.write();
+		this.newline(this.tasks.length + 1);
+		this.log(styles.reset.close);
+	}
+	write() {
+		if (this.status === "idle") throw new Error("Cannot write to stdout if status is 'idle'.");
+		const columns = stdout.columns ?? Logger.defaultColumns;
+		for (const [taskIndex, task] of this.tasks.entries()) {
+			const width = columns - 1;
+			const { left, right } = this.render(task, width);
+			this.reset(task);
+			this.icon(task);
+			this.padding(2);
+			this.log(left);
+			const centerPadding = Math.max(1, width - (4 + left.length + right.length));
+			this.padding(centerPadding);
+			this.log(right);
+			if (taskIndex !== this.tasks.length - 1) this.down(1);
+		}
+		if (this.tasks.length > 1) this.up(this.tasks.length - 1);
+	}
+	dot() {
+		const dotIndex = this.tick % Logger.dots.length;
+		const dot = Logger.dots[dotIndex];
+		if (dot === void 0) throw new Error(`Invalid index '${dotIndex}' to access dots of length '${Logger.dots.length}'.`);
+		this.log(dot);
+	}
+	log(message) {
+		stdout.write(message);
+	}
+	truncate(text, maxWidth) {
+		if (text.length <= maxWidth) return text;
+		if (maxWidth < 1) return "";
+		return `${text.slice(0, maxWidth - 1)}…`;
+	}
+	render(task, width) {
+		const rightText = this.truncate(task.step ?? "", Math.max(0, width - 5 - task.name.length));
+		return {
+			left: this.truncate(task.name, Math.max(0, width - 4 - rightText.length)),
+			right: rightText
+		};
+	}
+	reset(task) {
+		let color = styles.yellow.open;
+		if (task.status === "done") color = styles.green.open;
+		this.log(escapes.cursorLeft);
+		this.log(escapes.eraseLine);
+		this.log(color);
+	}
+	icon(task) {
+		if (task.status === "idle") this.padding(2);
+		else if (task.status === "in-progress") this.dot();
+		else this.log(Logger.check);
+	}
+	padding(count = 1) {
+		this.log(" ".repeat(count));
+	}
+	newline(count = 1) {
+		this.log("\n".repeat(count));
+	}
+	up(count = 1) {
+		this.log(escapes.cursorUp(count));
+	}
+	down(count = 1) {
+		this.log(escapes.cursorDown(count));
+	}
+	banner(title) {
+		const columns = stdout.columns ?? Logger.defaultColumns;
+		const width = Math.max(4, columns - 2);
+		const text = ` ${title} `;
+		const remaining = Math.max(0, width - text.length);
+		const leftPadding = Math.floor(remaining / 2);
+		const rightPadding = remaining - leftPadding;
+		const leftText = " ".repeat(leftPadding) + text + " ".repeat(rightPadding);
+		const top = `╭${"─".repeat(width)}╮`;
+		const middle = `│${styles.bold.open}${styles.white.open}${leftText}${styles.white.close}${styles.bold.close}${styles.blue.open}│`;
+		const bottom = `╰${"─".repeat(width)}╯`;
+		this.log(styles.blue.open);
+		this.log(escapes.cursorLeft);
+		this.log(escapes.eraseLine);
+		this.log(top);
+		this.newline();
+		this.log(escapes.cursorLeft);
+		this.log(middle);
+		this.newline();
+		this.log(escapes.cursorLeft);
+		this.log(bottom);
+		this.log(styles.blue.close);
+		this.newline();
+	}
+};
+//#endregion
+//#region source/modules/dependency-manager/dependency-manager.ts
+var DependencyManager = class {
+	queue;
+	constructor() {
+		this.queue = Promise.resolve();
+	}
+	async commandExists(command) {
+		try {
+			await execa("command", ["-v", command], {
+				shell: true,
+				stdin: "ignore"
+			});
+			return true;
+		} catch {
+			const commandFilePath = path.join(os.homedir(), ".local", "bin", command);
+			return await fs.stat(commandFilePath, { throwIfNoEntry: false }) !== void 0;
+		}
+	}
+	async isInstalled(dependencies) {
+		return (await Promise.all(dependencies.map(async (dependency) => {
+			try {
+				const { stdout } = await execa("dpkg-query", [
+					"--show",
+					"--showformat=${Status}",
+					dependency
+				]);
+				return stdout.includes("install ok installed");
+			} catch {
+				return false;
+			}
+		}))).every((installation) => installation === true);
+	}
+	async install(dependencies, task) {
+		await this.enqueue([
+			"install",
+			"-y",
+			"--no-install-recommends",
+			...dependencies
+		], task);
+	}
+	async update(task) {
+		await this.enqueue(["update"], task);
+	}
+	enqueue(managerArguments, task) {
+		const operation = this.queue.then(async () => {
+			const subprocess = execa("sudo", [
+				"env",
+				...["DEBIAN_FRONTEND=noninteractive", "NEEDRESTART_SUSPEND=1"],
+				"apt-get",
+				...managerArguments
+			], { stdin: "ignore" });
+			let partial = "";
+			subprocess.stdout?.on("data", (chunk) => {
+				partial += chunk.toString();
+				const lines = partial.split(/\r\n|\r|\n/);
+				partial = lines.pop() ?? "";
+				const line = lines.at(-1)?.trim();
+				if (line) task.continue(line);
+			});
+			await subprocess;
+		});
+		this.queue = operation.catch(() => {});
+		return operation;
+	}
+};
+//#endregion
+//#region source/modules/task/task.ts
+var Task = class {
+	name;
+	status;
+	step;
+	constructor(name) {
+		this.name = name;
+		this.status = "idle";
+		this.step = void 0;
+	}
+	start() {
+		if (this.status !== "idle") throw new Error(`Cannot start task '${this.name}' when status is '${this.status}'.`);
+		this.status = "in-progress";
+	}
+	continue(step) {
+		if (this.status !== "in-progress") throw new Error(`Cannot update task '${this.name}' step when status is '${this.status}'.`);
+		this.step = step;
+	}
+	finish() {
+		if (this.status !== "in-progress") throw new Error(`Cannot finish task '${this.name}' when status is '${this.status}'.`);
+		this.step = void 0;
+		this.status = "done";
+	}
+};
+//#endregion
+//#region source/modules/agent-rules/agent-rules.ts
+var AgentRules = class {
+	async install(context) {
+		const task = new Task("Agent Rules");
+		context.logger.add(task);
+		task.start();
+		const destinationDirectoryPath = path.join(context.directories.home, ".config", "zed");
+		const destinationFilePath = path.join(destinationDirectoryPath, "AGENTS.md");
+		const sourceFilePath = path.join(context.directories.assets, "AGENTS.md");
+		task.continue("Create global rules directory");
+		await fs.mkdir(destinationDirectoryPath, { recursive: true });
+		task.continue("Copy agent rules");
+		await fs.copyFile(sourceFilePath, destinationFilePath);
+		task.finish();
+	}
+};
+//#endregion
+//#region source/modules/agent-skills/agent-skills.ts
+var AgentSkills = class {
+	async install(context) {
+		const task = new Task("Agent Skills");
+		context.logger.add(task);
+		task.start();
+		const destinationDirectoryPath = path.join(context.directories.home, ".agents", "skills");
+		const sourceDirectoryPath = path.join(context.directories.assets, "skills");
+		task.continue("Create global skills directory");
+		await fs.mkdir(destinationDirectoryPath, { recursive: true });
+		task.continue("Copy agent skills");
+		await fs.cp(sourceDirectoryPath, destinationDirectoryPath, { recursive: true });
+		task.finish();
+	}
+};
+//#endregion
+//#region source/modules/auto-suggestion/auto-suggestion.ts
+var AutoSuggestion = class {
+	async install(context) {
+		const task = new Task("Auto Suggestion");
+		context.logger.add(task);
+		task.start();
+		const destinationDirectoryPath = path.join(context.directories.home, ".local", "share");
+		const installedFilePath = path.join(destinationDirectoryPath, "blesh", "ble.sh");
+		const sourceFilePath = path.join(context.directories.assets, ".blerc");
+		const destinationFilePath = path.join(context.directories.home, ".blerc");
+		if (!(await fs.stat(installedFilePath, { throwIfNoEntry: false }) !== void 0)) {
+			task.continue("Update package manager");
+			await context.dependencyManager.update(task);
+			const dependencies = ["xz-utils"];
+			task.continue(`Installing dependencies: ${dependencies.join(", ")}`);
+			await context.dependencyManager.install(dependencies, task);
+			const temporaryDirectoryPath = await fs.mkdtemp(path.join(os.tmpdir(), "ble.sh"));
+			const installationFilePath = path.join(temporaryDirectoryPath, "ble-nightly", "ble.sh");
+			task.continue("Download ble.sh");
+			await execa(`curl -L https://github.com/akinomyoga/ble.sh/releases/download/nightly/ble-nightly.tar.xz | tar xJf - -C ${temporaryDirectoryPath}`, { shell: true });
+			task.continue("Install ble.sh");
+			await execa(`bash ${installationFilePath} --install ${destinationDirectoryPath}`, { shell: true });
+			task.continue("Remove temporary directory");
+			await fs.rm(temporaryDirectoryPath, { recursive: true });
+		}
+		task.continue("Copy configuration");
+		await fs.copyFile(sourceFilePath, destinationFilePath);
+		task.finish();
+	}
+};
+//#endregion
+//#region source/modules/browser/browser.ts
+var Browser = class {
+	async install(context) {
+		const task = new Task("Browser");
+		context.logger.add(task);
+		task.start();
+		const dependencies = ["google-chrome-stable"];
+		if (await context.dependencyManager.isInstalled(dependencies)) {
+			task.finish();
+			return;
+		}
+		task.continue("Update package manager");
+		await context.dependencyManager.update(task);
+		const systemDependencies = ["gnupg"];
+		task.continue(`Installing dependencies: ${systemDependencies.join(", ")}`);
+		await context.dependencyManager.install(systemDependencies, task);
+		const keyringFilePath = path.join("/", "usr", "share", "keyrings", "google-chrome.gpg");
+		const sourceFilePath = path.join("/", "etc", "apt", "sources.list.d", "google-chrome.list");
+		task.continue("Set up google chrome sources");
+		await execa(`curl -fsSL https://dl.google.com/linux/linux_signing_key.pub | sudo gpg --dearmor --yes -o ${keyringFilePath}`, { shell: true });
+		await execa(`echo 'deb [arch=amd64 signed-by=${keyringFilePath}] http://dl.google.com/linux/chrome/deb/ stable main' | sudo tee ${sourceFilePath} > /dev/null`, { shell: true });
+		task.continue("Update package manager");
+		await context.dependencyManager.update(task);
+		task.continue(`Installing dependencies: ${dependencies.join(", ")}`);
+		await context.dependencyManager.install(dependencies, task);
+		task.finish();
+	}
+};
+//#endregion
+//#region source/modules/code-editor/code-editor.ts
+var CodeEditor = class {
+	async install(context) {
+		const task = new Task("Code Editor");
+		context.logger.add(task);
+		task.start();
+		const sourceDirectoryPath = path.join(context.directories.assets, "zed");
+		const destinationDirectoryPath = path.join(context.directories.home, ".config", "zed");
+		task.continue("Install Zed");
+		if (!await context.dependencyManager.commandExists("zed")) await execa("curl -f https://zed.dev/install.sh | sh", { shell: true });
+		task.continue("Copy configuration");
+		await fs.cp(sourceDirectoryPath, destinationDirectoryPath, { recursive: true });
+		task.finish();
+	}
+};
+//#endregion
+//#region source/modules/code-host/code-host.ts
+var CodeHost = class {
+	async install(context) {
+		const task = new Task("Code Host");
+		context.logger.add(task);
+		task.start();
+		const dependencies = ["gh"];
+		if (await context.dependencyManager.isInstalled(dependencies)) {
+			task.finish();
+			return;
+		}
+		task.continue("Update package manager");
+		await context.dependencyManager.update(task);
+		const systemDependencies = ["gnupg"];
+		task.continue(`Installing dependencies: ${systemDependencies.join(", ")}`);
+		await context.dependencyManager.install(systemDependencies, task);
+		const keyringFilePath = path.join("/", "usr", "share", "keyrings", "github-cli.gpg");
+		const sourceFilePath = path.join("/", "etc", "apt", "sources.list.d", "github-cli.list");
+		task.continue("Set up github cli sources");
+		await execa(`curl -fsSL https://cli.github.com/packages/githubcli-archive-keyring.asc | sudo gpg --dearmor --yes -o ${keyringFilePath}`, { shell: true });
+		await execa(`echo "deb [arch=$(dpkg --print-architecture) signed-by=${keyringFilePath}] https://cli.github.com/packages stable main" | sudo tee ${sourceFilePath} > /dev/null`, { shell: true });
+		task.continue("Update package manager");
+		await context.dependencyManager.update(task);
+		task.continue(`Installing dependencies: ${dependencies.join(", ")}`);
+		await context.dependencyManager.install(dependencies, task);
+		task.finish();
+	}
+};
+//#endregion
+//#region source/modules/container-engine/container-engine.ts
+var ContainerEngine = class {
+	async install(context) {
+		const task = new Task("Container Engine");
+		context.logger.add(task);
+		task.start();
+		const dependencies = [
+			"docker-ce",
+			"docker-ce-cli",
+			"containerd.io",
+			"docker-buildx-plugin",
+			"docker-compose-plugin"
+		];
+		if (await context.dependencyManager.isInstalled(dependencies)) {
+			task.finish();
+			return;
+		}
+		task.continue("Update package manager");
+		await context.dependencyManager.update(task);
+		const systemDependencies = ["gnupg"];
+		task.continue(`Installing dependencies: ${systemDependencies.join(", ")}`);
+		await context.dependencyManager.install(systemDependencies, task);
+		const keyringFilePath = path.join("/", "usr", "share", "keyrings", "docker.gpg");
+		const sourceFilePath = path.join("/", "etc", "apt", "sources.list.d", "docker.list");
+		task.continue("Set up docker sources");
+		await execa(`curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor --yes -o ${keyringFilePath}`, { shell: true });
+		await execa(`echo "deb [arch=$(dpkg --print-architecture) signed-by=${keyringFilePath}] https://download.docker.com/linux/ubuntu $(. /etc/os-release && echo $VERSION_CODENAME) stable" | sudo tee ${sourceFilePath} > /dev/null`, { shell: true });
+		task.continue("Update package manager");
+		await context.dependencyManager.update(task);
+		task.continue(`Installing dependencies: ${dependencies.join(", ")}`);
+		await context.dependencyManager.install(dependencies, task);
+		task.continue("Add user to docker group");
+		await execa(`sudo usermod --append --groups docker ${os.userInfo().username}`, { shell: true });
+		task.finish();
+	}
+};
+//#endregion
+//#region source/modules/fonts/fonts.ts
+var Fonts = class {
+	async install(context) {
+		const task = new Task("Fonts");
+		context.logger.add(task);
+		task.start();
+		const dependencies = ["fontconfig"];
+		if (!await context.dependencyManager.isInstalled(dependencies)) {
+			task.continue("Update package manager");
+			await context.dependencyManager.update(task);
+			task.continue(`Installing dependencies: ${dependencies.join(", ")}`);
+			await context.dependencyManager.install(dependencies, task);
+		}
+		const sourceDirectoryPath = path.join(context.directories.assets, "fonts");
+		const destinationDirectoryPath = path.join(context.directories.home, ".local", "share", "fonts");
+		task.continue("Create fonts directory");
+		await fs.mkdir(destinationDirectoryPath, { recursive: true });
+		task.continue("Copy fonts");
+		await fs.cp(sourceDirectoryPath, destinationDirectoryPath, { recursive: true });
+		task.finish();
+	}
+};
+//#endregion
+//#region source/modules/fuzzy-finder/fuzzy-finder.ts
+var FuzzyFinder = class {
+	async install(context) {
+		const task = new Task("Fuzzy Finder");
+		context.logger.add(task);
+		task.start();
+		const dependencies = ["fzf"];
+		if (await context.dependencyManager.isInstalled(dependencies)) {
+			task.finish();
+			return;
+		}
+		task.continue("Update package manager");
+		await context.dependencyManager.update(task);
+		task.continue(`Installing dependencies: ${dependencies.join(", ")}`);
+		await context.dependencyManager.install(dependencies, task);
+		task.finish();
+	}
+};
+//#endregion
+//#region source/modules/password-manager/password-manager.ts
+var PasswordManager = class {
+	async install(context) {
+		const task = new Task("Password Manager");
+		context.logger.add(task);
+		task.start();
+		const dependencies = ["libasound2t64", "1password"];
+		if (await context.dependencyManager.isInstalled(dependencies)) {
+			task.finish();
+			return;
+		}
+		task.continue("Update package manager");
+		await context.dependencyManager.update(task);
+		const systemDependencies = ["gnupg"];
+		task.continue(`Installing dependencies: ${systemDependencies.join(", ")}`);
+		await context.dependencyManager.install(systemDependencies, task);
+		const keyringFilePath = path.join("/", "usr", "share", "keyrings", "1password-archive-keyring.gpg");
+		const sourceFilePath = path.join("/", "etc", "apt", "sources.list.d", "1password.list");
+		const policyDirectoryPath = path.join("/", "etc", "debsig", "policies", "AC2D62742012EA22");
+		const policyFilePath = path.join(policyDirectoryPath, "1password.pol");
+		const debsigKeyringDirectoryPath = path.join("/", "usr", "share", "debsig", "keyrings", "AC2D62742012EA22");
+		const debsigKeyringFilePath = path.join(debsigKeyringDirectoryPath, "debsig.gpg");
+		task.continue("Set up 1password sources");
+		await execa(`curl -sS https://downloads.1password.com/linux/keys/1password.asc | sudo gpg --dearmor --yes --output ${keyringFilePath}`, { shell: true });
+		await execa(`echo 'deb [arch=amd64 signed-by=${keyringFilePath}] https://downloads.1password.com/linux/debian/amd64 stable main' | sudo tee ${sourceFilePath}`, { shell: true });
+		await execa(`sudo mkdir -p ${policyDirectoryPath}`, { shell: true });
+		await execa(`curl -sS https://downloads.1password.com/linux/debian/debsig/1password.pol | sudo tee ${policyFilePath}`, { shell: true });
+		await execa(`sudo mkdir -p ${debsigKeyringDirectoryPath}`, { shell: true });
+		await execa(`curl -sS https://downloads.1password.com/linux/keys/1password.asc | sudo gpg --dearmor --yes --output ${debsigKeyringFilePath}`, { shell: true });
+		task.continue("Update package manager");
+		await context.dependencyManager.update(task);
+		task.continue(`Installing dependencies: ${dependencies.join(", ")}`);
+		await context.dependencyManager.install(dependencies, task);
+		task.finish();
+	}
+};
+//#endregion
+//#region source/modules/shell-configuration/shell-configuration.ts
+var ShellConfiguration = class {
+	async install(context) {
+		const task = new Task("Shell Configuration");
+		context.logger.add(task);
+		task.start();
+		const sourceFilePath = path.join(context.directories.assets, ".bashrc");
+		const destinationFilePath = path.join(context.directories.home, ".bashrc");
+		task.continue("Copy shell configuration");
+		await fs.copyFile(sourceFilePath, destinationFilePath);
+		task.finish();
+	}
+};
+//#endregion
+//#region source/modules/smart-change-directory/smart-change-directory.ts
+var SmartChangeDirectory = class {
+	async install(context) {
+		const task = new Task("Smart Change Directory");
+		context.logger.add(task);
+		task.start();
+		const dependencies = ["zoxide"];
+		if (await context.dependencyManager.isInstalled(dependencies)) {
+			task.finish();
+			return;
+		}
+		task.continue("Update package manager");
+		await context.dependencyManager.update(task);
+		task.continue(`Installing dependencies: ${dependencies.join(", ")}`);
+		await context.dependencyManager.install(dependencies, task);
+		task.finish();
+	}
+};
+//#endregion
+//#region source/modules/terminal-view/terminal-view.ts
+var TerminalView = class {
+	async install(context) {
+		const task = new Task("Terminal View");
+		context.logger.add(task);
+		task.start();
+		if (!await context.dependencyManager.commandExists("oh-my-posh")) {
+			task.continue("Update package manager");
+			await context.dependencyManager.update(task);
+			const dependencies = ["unzip"];
+			task.continue(`Installing dependencies: ${dependencies.join(", ")}`);
+			await context.dependencyManager.install(dependencies, task);
+			task.continue("Install oh-my-posh");
+			await execa("curl -s https://ohmyposh.dev/install.sh | bash -s", { shell: true });
+		}
+		const sourceFilePath = path.join(context.directories.assets, "oh-my-posh.toml");
+		const destinationDirectoryPath = path.join(context.directories.home, ".config", "oh-my-posh");
+		const destinationFilePath = path.join(destinationDirectoryPath, "oh-my-posh.toml");
+		task.continue("Create configuration directory");
+		await fs.mkdir(destinationDirectoryPath, { recursive: true });
+		task.continue("Copy configuration");
+		await fs.copyFile(sourceFilePath, destinationFilePath);
+		task.finish();
+	}
+};
+//#endregion
+//#region source/modules/version-control-system/version-control-system.ts
+var VersionControlSystem = class {
+	async install(context) {
+		const task = new Task("Version Control System");
+		context.logger.add(task);
+		task.start();
+		const dependencies = ["git", "build-essential"];
+		if (await context.dependencyManager.isInstalled(dependencies)) {
+			task.finish();
+			return;
+		}
+		task.continue("Update package manager");
+		await context.dependencyManager.update(task);
+		task.continue(`Installing dependencies: ${dependencies.join(", ")}`);
+		await context.dependencyManager.install(dependencies, task);
+		task.finish();
+	}
+};
+//#endregion
+//#region source/modules/wallpapers/wallpapers.ts
+var Wallpapers = class {
+	async install(context) {
+		const task = new Task("Wallpapers");
+		context.logger.add(task);
+		task.start();
+		const dependencies = ["hydrapaper"];
+		if (!await context.dependencyManager.isInstalled(dependencies)) {
+			task.continue("Update package manager");
+			await context.dependencyManager.update(task);
+			task.continue(`Installing dependencies: ${dependencies.join(", ")}`);
+			await context.dependencyManager.install(dependencies, task);
+		}
+		const sourceDirectoryPath = path.join(context.directories.assets, "wallpapers");
+		const destinationDirectoryPath = path.join(context.directories.home, ".local", "share", "backgrounds");
+		task.continue("Create backgrounds directory");
+		await fs.mkdir(destinationDirectoryPath, { recursive: true });
+		task.continue("Copy wallpapers");
+		await fs.cp(sourceDirectoryPath, destinationDirectoryPath, { recursive: true });
+		task.finish();
+	}
+};
 //#endregion
 //#region source/setup-ubuntu.ts
-program.name("@hurshb50/setup-ubuntu").version("0.0.0").description("TODO");
+program.name(name).version(version).description("TODO").action(async () => {
+	const logger = new Logger();
+	const dependencyManager = new DependencyManager();
+	logger.start();
+	const packages = [
+		new AgentRules(),
+		new AgentSkills(),
+		new AutoSuggestion(),
+		new Browser(),
+		new CodeEditor(),
+		new CodeHost(),
+		new ContainerEngine(),
+		new Fonts(),
+		new FuzzyFinder(),
+		new PasswordManager(),
+		new ShellConfiguration(),
+		new SmartChangeDirectory(),
+		new TerminalView(),
+		new VersionControlSystem(),
+		new Wallpapers()
+	];
+	try {
+		const directories = {
+			current: import.meta.dirname,
+			assets: path.join(import.meta.dirname, "assets"),
+			home: os.homedir()
+		};
+		const installations = packages.map(({ install }) => install({
+			dependencyManager,
+			directories,
+			logger
+		}));
+		await Promise.all(installations);
+	} finally {
+		logger.stop();
+	}
+});
 program.parse();
 //#endregion
 export {};

package/package.json

@@ -1,22 +1,27 @@
 {
     "name": "@hurshb50/setup-ubuntu",
-    "version": "0.0.1",
+    "version": "0.0.3",
     "type": "module",
     "files": [
         "distribution"
     ],
-    "bin": "./distribution/setup-ubuntu.js",
+    "bin": "./distribution/setup-ubuntu.mjs",
     "scripts": {
         "build": "vp pack",
         "check": "vp check",
-        "check-fix": "vp check --fix",
-        "test": "vp test",
-        "test-watch": "vp test --watch"
+        "fix": "vp check --fix",
+        "unit-test": "vp test --project unit",
+        "integration-test": "node scripts/integration.ts",
+        "end-to-end-test": "docker build -t setup-ubuntu:end-to-end -f ./docker/end-to-end.dockerfile . && docker run --rm setup-ubuntu:end-to-end"
     },
     "dependencies": {
         "@commander-js/extra-typings": "^15.0.0",
-        "@types/bun": "latest",
-        "bumpp": "^11.1.0",
+        "ansi-escapes": "^7.3.0",
+        "ansi-styles": "^7.0.0",
+        "execa": "^10.0.1"
+    },
+    "devDependencies": {
+        "@types/node": "latest",
         "typescript": "^7.0.2",
         "vite": "npm:@voidzero-dev/vite-plus-core@0.3.1",
         "vite-plus": "^0.2.4"