@tomagranate/corsa 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 corsa contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,226 @@
+# Corsa
+
+A Terminal User Interface (TUI) for managing multiple local development processes. View real-time logs, monitor status, and control all your dev servers from a single dashboard.
+
+Built with [OpenTUI](https://github.com/anomalyco/opentui).
+
+## Why Corsa?
+
+When working on a full-stack project, you often need to run multiple processes simultaneously—a frontend dev server, a backend API, database containers, workers, etc. Corsa gives you:
+
+- **Single dashboard** for all your processes with tabbed log viewing
+- **Real-time logs** with search and ANSI color support
+- **Status monitoring** to see at a glance what's running, stopped, or crashed
+- **Health checks** to monitor service availability
+- **AI integration** via MCP to let your IDE assistant read logs and control processes
+
+## Installation
+
+### Homebrew (macOS and Linux)
+
+```bash
+brew install tomagranate/tap/corsa
+```
+
+### NPM
+
+```bash
+npm install -g @tomagranate/corsa
+```
+
+### curl (macOS and Linux)
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/tomagranate/corsa/main/install.sh | bash
+```
+
+### Manual Download
+
+Download the latest binary for your platform from [Releases](https://github.com/tomagranate/corsa/releases).
+
+| Platform | Download |
+|----------|----------|
+| macOS (Apple Silicon) | `corsa-darwin-arm64.tar.gz` |
+| macOS (Intel) | `corsa-darwin-x64.tar.gz` |
+| Linux (x64) | `corsa-linux-x64.tar.gz` |
+| Linux (ARM64) | `corsa-linux-arm64.tar.gz` |
+| Windows (x64) | `corsa-windows-x64.zip` |
+
+## Quick Start
+
+1. Create a config file in your project:
+
+```bash
+corsa init
+```
+
+2. Edit `corsa.config.toml` to add your processes:
+
+```toml
+[[tools]]
+name = "frontend"
+command = "npm"
+args = ["run", "dev"]
+cwd = "./frontend"
+
+[[tools]]
+name = "backend"
+command = "python"
+args = ["-m", "uvicorn", "main:app", "--reload"]
+cwd = "./backend"
+```
+
+3. Start the dashboard:
+
+```bash
+corsa
+```
+
+## CLI Reference
+
+### Commands
+
+| Command | Description |
+|---------|-------------|
+| `corsa` | Start the TUI dashboard |
+| `corsa init` | Create a sample config file in the current directory |
+| `corsa mcp` | Start the MCP server for AI agent integration |
+
+### Options
+
+| Option | Description |
+|--------|-------------|
+| `-c, --config <path>` | Path to config file (default: `corsa.config.toml`) |
+| `-h, --help` | Show help message |
+
+### Examples
+
+```bash
+# Start with default config
+corsa
+
+# Use a custom config file
+corsa --config ./configs/dev.toml
+corsa -c ./configs/dev.toml
+
+# Create a new config file
+corsa init
+
+# Start MCP server for AI integration
+corsa mcp
+```
+
+## Configuration
+
+Corsa is configured via a TOML file. By default, it looks for `corsa.config.toml` in the current directory.
+
+### Minimal Example
+
+```toml
+[[tools]]
+name = "server"
+command = "npm"
+args = ["run", "dev"]
+```
+
+### Full Example
+
+```toml
+[home]
+enabled = true
+title = "My Project"
+
+[ui]
+theme = "mist"
+showTabNumbers = true
+
+[mcp]
+enabled = true
+
+[[tools]]
+name = "web"
+command = "npm"
+args = ["run", "dev"]
+cwd = "./web"
+description = "Next.js frontend"
+
+[tools.ui]
+label = "Open App"
+url = "http://localhost:3000"
+
+[tools.healthCheck]
+url = "http://localhost:3000/api/health"
+interval = 5000
+
+[[tools]]
+name = "api"
+command = "cargo"
+args = ["watch", "-x", "run"]
+cwd = "./api"
+description = "Rust API server"
+cleanup = ["pkill -f 'target/debug/api'"]
+
+[tools.env]
+RUST_LOG = "debug"
+```
+
+For a complete reference of all configuration options, see the [sample config file](src/sample-config.toml).
+
+
+
+## Themes
+
+Corsa includes several built-in themes. Set in your config:
+
+```toml
+[ui]
+theme = "mist"
+```
+
+Available themes: `default` (Moss), `mist`, `cappuccino`, `synthwave`, `terminal` (auto-detect from your terminal).
+
+## MCP Integration
+
+Corsa can expose an HTTP API for AI agents (Cursor, Claude, etc.) via the Model Context Protocol.
+
+### Enable in Config
+
+```toml
+[mcp]
+enabled = true
+port = 18765
+```
+
+### Configure Your IDE
+
+Add to your MCP configuration (e.g., `~/.cursor/mcp.json`):
+
+```json
+{
+  "mcpServers": {
+    "corsa": {
+      "command": "corsa",
+      "args": ["mcp"]
+    }
+  }
+}
+```
+
+### Available MCP Tools
+
+| Tool | Description |
+|------|-------------|
+| `list_processes` | List all processes with status, health, and last 20 log lines |
+| `get_logs` | Get recent logs (supports search and line limits) |
+| `stop_process` | Stop a running process |
+| `restart_process` | Restart a process |
+| `clear_logs` | Clear logs for a process |
+| `reload_config` | Reload config file and restart all processes |
+
+## Contributing
+
+See the [Contributing Guide](CONTRIBUTING.md) for development setup and guidelines.
+
+## License
+
+MIT

package/bin/corsa

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __filename = fileURLToPath(import.meta.url);
+const binDir = dirname(__filename);
+const platform = process.platform;
+const arch = process.arch;
+
+// Map Node.js platform/arch to our binary names
+const platformMap = {
+	darwin: "darwin",
+	linux: "linux",
+	win32: "windows",
+};
+
+const archMap = {
+	arm64: "arm64",
+	x64: "x64",
+};
+
+const os = platformMap[platform];
+const cpu = archMap[arch];
+
+if (!os || !cpu) {
+	console.error(`Unsupported platform: ${platform}-${arch}`);
+	process.exit(1);
+}
+
+const binaryName = `corsa-${os}-${cpu}${platform === "win32" ? ".exe" : ""}`;
+const binaryPath = join(binDir, binaryName);
+
+if (!existsSync(binaryPath)) {
+	console.error(`Binary not found: ${binaryPath}`);
+	console.error(
+		"This may happen if the postinstall script failed to download the binary.",
+	);
+	console.error("Try reinstalling: npm install -g corsa");
+	process.exit(1);
+}
+
+// Execute the binary with all arguments passed through
+const child = spawn(binaryPath, process.argv.slice(2), {
+	stdio: "inherit",
+	windowsHide: true,
+});
+
+child.on("error", (err) => {
+	console.error(`Failed to start corsa: ${err.message}`);
+	process.exit(1);
+});
+
+child.on("exit", (code, signal) => {
+	if (signal) {
+		process.kill(process.pid, signal);
+	} else {
+		process.exit(code ?? 0);
+	}
+});

package/bin/toolui

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __filename = fileURLToPath(import.meta.url);
+const binDir = dirname(__filename);
+const platform = process.platform;
+const arch = process.arch;
+
+// Map Node.js platform/arch to our binary names
+const platformMap = {
+	darwin: "darwin",
+	linux: "linux",
+	win32: "windows",
+};
+
+const archMap = {
+	arm64: "arm64",
+	x64: "x64",
+};
+
+const os = platformMap[platform];
+const cpu = archMap[arch];
+
+if (!os || !cpu) {
+	console.error(`Unsupported platform: ${platform}-${arch}`);
+	process.exit(1);
+}
+
+const binaryName = `corsa-${os}-${cpu}${platform === "win32" ? ".exe" : ""}`;
+const binaryPath = join(binDir, binaryName);
+
+if (!existsSync(binaryPath)) {
+	console.error(`Binary not found: ${binaryPath}`);
+	console.error(
+		"This may happen if the postinstall script failed to download the binary.",
+	);
+	console.error("Try reinstalling: npm install -g corsa");
+	process.exit(1);
+}
+
+// Execute the binary with all arguments passed through
+const child = spawn(binaryPath, process.argv.slice(2), {
+	stdio: "inherit",
+	windowsHide: true,
+});
+
+child.on("error", (err) => {
+	console.error(`Failed to start corsa: ${err.message}`);
+	process.exit(1);
+});
+
+child.on("exit", (code, signal) => {
+	if (signal) {
+		process.kill(process.pid, signal);
+	} else {
+		process.exit(code ?? 0);
+	}
+});

package/package.json

@@ -0,0 +1,61 @@
+{
+	"name": "@tomagranate/corsa",
+	"version": "1.0.0",
+	"description": "A Terminal User Interface (TUI) for running multiple local development servers and tools simultaneously",
+	"type": "module",
+	"bin": {
+		"corsa": "bin/corsa"
+	},
+	"files": [
+		"bin",
+		"scripts"
+	],
+	"scripts": {
+		"dev": "bun run src/index.tsx",
+		"build": "bun build src/index.tsx --compile --minify --outfile dist/corsa",
+		"build:all": "bun run scripts/build-all.ts",
+		"postinstall": "node scripts/postinstall.cjs",
+		"check": "biome check --fix",
+		"check:nofix": "biome check",
+		"lint": "bun check",
+		"format": "bun check",
+		"typecheck": "tsc --noEmit",
+		"test": "bun test",
+		"test:watch": "bun test --watch",
+		"prepublishOnly": "bun run typecheck && bun run check:nofix"
+	},
+	"keywords": [
+		"cli",
+		"tui",
+		"terminal",
+		"devtools",
+		"process-manager",
+		"dev-server",
+		"multiplexer"
+	],
+	"author": "",
+	"license": "MIT",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/tomagranate/corsa.git"
+	},
+	"homepage": "https://github.com/tomagranate/corsa#readme",
+	"bugs": {
+		"url": "https://github.com/tomagranate/corsa/issues"
+	},
+	"engines": {
+		"node": ">=18.0.0"
+	},
+	"devDependencies": {
+		"@iarna/toml": "^2.2.5",
+		"@modelcontextprotocol/sdk": "^1.25.3",
+		"@opentui/core": "^0.1.72",
+		"@opentui/react": "^0.1.72",
+		"fuzzysort": "^3.1.0",
+		"react": "^19.2.3",
+		"zod": "^4.3.6",
+		"@biomejs/biome": "^2.3.11",
+		"@types/bun": "latest",
+		"typescript": "^5.9.3"
+	}
+}

package/scripts/build-all.ts

@@ -0,0 +1,81 @@
+#!/usr/bin/env bun
+
+/**
+ * Build corsa binaries for all supported platforms.
+ *
+ * Usage:
+ *   bun run scripts/build-all.ts
+ *   bun run scripts/build-all.ts --version 0.1.0
+ */
+
+import { mkdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { $ } from "bun";
+
+interface BuildTarget {
+	target: string;
+	os: string;
+	arch: string;
+	extension: string;
+}
+
+const TARGETS: BuildTarget[] = [
+	{ target: "bun-darwin-arm64", os: "darwin", arch: "arm64", extension: "" },
+	{ target: "bun-darwin-x64", os: "darwin", arch: "x64", extension: "" },
+	{ target: "bun-linux-x64", os: "linux", arch: "x64", extension: "" },
+	{ target: "bun-linux-arm64", os: "linux", arch: "arm64", extension: "" },
+	{
+		target: "bun-windows-x64",
+		os: "windows",
+		arch: "x64",
+		extension: ".exe",
+	},
+];
+
+async function getVersion(): Promise<string> {
+	// Check for --version flag
+	const versionIndex = process.argv.indexOf("--version");
+	const versionArg = process.argv[versionIndex + 1];
+	if (versionIndex !== -1 && versionArg) {
+		return versionArg;
+	}
+
+	// Read from package.json
+	const packageJson = JSON.parse(
+		await readFile(join(import.meta.dir, "..", "package.json"), "utf-8"),
+	) as { version: string };
+	return packageJson.version;
+}
+
+async function buildTarget(target: BuildTarget, outDir: string): Promise<void> {
+	const outputName = `corsa-${target.os}-${target.arch}${target.extension}`;
+	const outputPath = join(outDir, outputName);
+
+	console.log(`Building ${outputName}...`);
+
+	await $`bun build src/index.tsx --compile --minify --target=${target.target} --outfile=${outputPath}`;
+
+	console.log(`  ✓ ${outputName}`);
+}
+
+async function main() {
+	const version = await getVersion();
+	const outDir = join(import.meta.dir, "..", "dist");
+
+	console.log(`\nBuilding corsa v${version} for all platforms\n`);
+
+	// Create output directory
+	await mkdir(outDir, { recursive: true });
+
+	// Build all targets
+	for (const target of TARGETS) {
+		await buildTarget(target, outDir);
+	}
+
+	console.log(`\n✓ All binaries built in ${outDir}\n`);
+}
+
+main().catch((error) => {
+	console.error("Build failed:", error);
+	process.exit(1);
+});

package/scripts/postinstall.cjs

@@ -0,0 +1,333 @@
+#!/usr/bin/env node
+
+/**
+ * Postinstall script for corsa NPM package.
+ * Downloads the appropriate binary for the current platform.
+ */
+
+const fs = require("node:fs");
+const path = require("node:path");
+const { execSync } = require("node:child_process");
+const zlib = require("node:zlib");
+
+// Configuration
+const REPO = "tomagranate/corsa";
+const GITHUB_RELEASES = `https://github.com/${REPO}/releases`;
+
+// Platform mappings
+const PLATFORM_MAP = {
+	darwin: "darwin",
+	linux: "linux",
+	win32: "windows",
+};
+
+const ARCH_MAP = {
+	arm64: "arm64",
+	x64: "x64",
+};
+
+// Colors (respects NO_COLOR env var)
+const useColor = !process.env.NO_COLOR && process.stdout.isTTY;
+const colors = {
+	reset: useColor ? "\x1b[0m" : "",
+	bold: useColor ? "\x1b[1m" : "",
+	dim: useColor ? "\x1b[2m" : "",
+	cyan: useColor ? "\x1b[36m" : "",
+	green: useColor ? "\x1b[32m" : "",
+	yellow: useColor ? "\x1b[33m" : "",
+	red: useColor ? "\x1b[31m" : "",
+};
+
+/**
+ * Print styled header
+ */
+function printHeader() {
+	console.log();
+	console.log(
+		`${colors.cyan}${colors.bold}  ╭─────────────────────────────────╮${colors.reset}`,
+	);
+	console.log(
+		`${colors.cyan}${colors.bold}  │        corsa postinstall        │${colors.reset}`,
+	);
+	console.log(
+		`${colors.cyan}${colors.bold}  ╰─────────────────────────────────╯${colors.reset}`,
+	);
+	console.log();
+}
+
+/**
+ * Print step message
+ */
+function step(msg) {
+	console.log(`  ${colors.cyan}▸${colors.reset} ${msg}`);
+}
+
+/**
+ * Print success message
+ */
+function success(msg) {
+	console.log();
+	console.log(
+		`${colors.green}${colors.bold}  ╭─────────────────────────────────╮${colors.reset}`,
+	);
+	console.log(
+		`${colors.green}${colors.bold}  │${colors.reset}   ${colors.green}✓${colors.reset} ${msg.padEnd(27)} ${colors.green}${colors.bold}│${colors.reset}`,
+	);
+	console.log(
+		`${colors.green}${colors.bold}  ╰─────────────────────────────────╯${colors.reset}`,
+	);
+	console.log();
+}
+
+/**
+ * Print error message
+ */
+function printError(msg) {
+	console.error(`  ${colors.red}✗${colors.reset} ${msg}`);
+}
+
+/**
+ * Format bytes as human-readable string
+ */
+function formatBytes(bytes) {
+	if (bytes < 1024) return `${bytes} B`;
+	if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+	return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+
+/**
+ * Show download progress bar
+ */
+function showProgress(downloaded, total) {
+	if (!process.stdout.isTTY) return;
+
+	const width = 24;
+	if (total) {
+		const percent = Math.min(100, (downloaded / total) * 100);
+		const filled = Math.floor((percent / 100) * width);
+		const empty = width - filled;
+		const bar = "█".repeat(filled) + "░".repeat(empty);
+		const percentStr = percent.toFixed(0).padStart(3);
+		process.stdout.write(
+			`\r    ${colors.dim}${bar}${colors.reset} ${percentStr}% ${colors.dim}(${formatBytes(downloaded)})${colors.reset}`,
+		);
+	} else {
+		process.stdout.write(
+			`\r    ${colors.dim}Downloading: ${formatBytes(downloaded)}${colors.reset}`,
+		);
+	}
+}
+
+/**
+ * Clear progress line
+ */
+function clearProgress() {
+	if (!process.stdout.isTTY) return;
+	process.stdout.write(`\r${" ".repeat(70)}\r`);
+}
+
+/**
+ * Download file with streaming and progress
+ */
+async function downloadWithProgress(url) {
+	const response = await fetch(url, {
+		headers: { "User-Agent": "corsa-postinstall" },
+	});
+
+	if (!response.ok) {
+		throw new Error(`HTTP ${response.status}`);
+	}
+
+	const contentLength = response.headers.get("content-length");
+	const total = contentLength ? parseInt(contentLength, 10) : null;
+	let downloaded = 0;
+
+	const chunks = [];
+	const reader = response.body.getReader();
+
+	while (true) {
+		const { done, value } = await reader.read();
+		if (done) break;
+
+		chunks.push(value);
+		downloaded += value.length;
+		showProgress(downloaded, total);
+	}
+
+	clearProgress();
+	return Buffer.concat(chunks);
+}
+
+/**
+ * Get the version from package.json
+ */
+function getVersion() {
+	const packageJson = JSON.parse(
+		fs.readFileSync(path.join(__dirname, "..", "package.json"), "utf-8"),
+	);
+	return packageJson.version;
+}
+
+/**
+ * Extract tar.gz archive to get the binary
+ */
+function extractTarGz(data, destPath) {
+	return new Promise((resolve, reject) => {
+		const gunzip = zlib.createGunzip();
+		const chunks = [];
+
+		gunzip.on("data", (chunk) => chunks.push(chunk));
+		gunzip.on("end", () => {
+			const tarData = Buffer.concat(chunks);
+			let offset = 0;
+			while (offset < tarData.length) {
+				const header = tarData.slice(offset, offset + 512);
+				if (header[0] === 0) break;
+
+				const filename = header
+					.slice(0, 100)
+					.toString("utf-8")
+					.replace(/\0/g, "");
+
+				const sizeStr = header
+					.slice(124, 136)
+					.toString("utf-8")
+					.replace(/\0/g, "")
+					.trim();
+				const size = parseInt(sizeStr, 8) || 0;
+
+				offset += 512;
+
+				if (filename && size > 0 && filename.startsWith("corsa")) {
+					const content = tarData.slice(offset, offset + size);
+					fs.writeFileSync(destPath, content);
+					fs.chmodSync(destPath, 0o755);
+					resolve();
+					return;
+				}
+
+				offset += Math.ceil(size / 512) * 512;
+			}
+			reject(new Error("Binary not found in archive"));
+		});
+		gunzip.on("error", reject);
+
+		gunzip.end(data);
+	});
+}
+
+/**
+ * Download and extract Unix binary
+ */
+async function downloadBinary(url, destPath) {
+	const data = await downloadWithProgress(url);
+	await extractTarGz(data, destPath);
+}
+
+/**
+ * Download and extract Windows binary
+ */
+async function downloadWindowsBinary(url, destPath) {
+	const data = await downloadWithProgress(url);
+
+	const zipPath = `${destPath}.zip`;
+	fs.writeFileSync(zipPath, data);
+
+	try {
+		if (process.platform === "win32") {
+			execSync(
+				`powershell -command "Expand-Archive -Path '${zipPath}' -DestinationPath '${path.dirname(destPath)}' -Force"`,
+				{ stdio: "pipe" },
+			);
+		} else {
+			execSync(`unzip -o "${zipPath}" -d "${path.dirname(destPath)}"`, {
+				stdio: "pipe",
+			});
+		}
+	} finally {
+		fs.unlinkSync(zipPath);
+	}
+}
+
+/**
+ * Download binary from URL
+ */
+async function downloadFromUrl(url, destPath, isWindows) {
+	if (isWindows) {
+		await downloadWindowsBinary(url, destPath);
+	} else {
+		await downloadBinary(url, destPath);
+	}
+}
+
+async function main() {
+	const platform = PLATFORM_MAP[process.platform];
+	const arch = ARCH_MAP[process.arch];
+
+	if (!platform || !arch) {
+		console.log();
+		console.log(
+			`  ${colors.yellow}!${colors.reset} Unsupported platform: ${process.platform}-${process.arch}`,
+		);
+		console.log(`    Build from source or download manually.`);
+		console.log();
+		process.exit(0);
+	}
+
+	const version = getVersion();
+	const binaryName = `corsa-${platform}-${arch}`;
+	const binDir = path.join(__dirname, "..", "bin");
+	const destPath = path.join(
+		binDir,
+		binaryName + (platform === "windows" ? ".exe" : ""),
+	);
+
+	// Skip if binary already exists
+	if (fs.existsSync(destPath)) {
+		console.log();
+		console.log(`  ${colors.dim}Binary already installed${colors.reset}`);
+		console.log();
+		return;
+	}
+
+	printHeader();
+
+	step(`Platform: ${colors.bold}${platform}-${arch}${colors.reset}`);
+	step(`Version: ${colors.bold}v${version}${colors.reset}`);
+	console.log();
+
+	// Ensure bin directory exists
+	if (!fs.existsSync(binDir)) {
+		fs.mkdirSync(binDir, { recursive: true });
+	}
+
+	const archiveExt = platform === "windows" ? "zip" : "tar.gz";
+	const url = `${GITHUB_RELEASES}/download/v${version}/${binaryName}.${archiveExt}`;
+
+	try {
+		step("Downloading binary...");
+		await downloadFromUrl(url, destPath, platform === "windows");
+
+		step("Extracting...");
+		success(`corsa v${version} ready`);
+
+		console.log(`  ${colors.dim}Get started:${colors.reset}`);
+		console.log(`  ${colors.cyan}$${colors.reset} corsa init`);
+		console.log(`  ${colors.cyan}$${colors.reset} corsa`);
+		console.log();
+	} catch (error) {
+		printError(`Download failed: ${error.message}`);
+		console.log();
+		console.log(`  ${colors.dim}Manual download:${colors.reset}`);
+		console.log(`  ${GITHUB_RELEASES}/latest`);
+		console.log();
+		console.log(`  ${colors.dim}Or use install script:${colors.reset}`);
+		console.log(
+			`  curl -fsSL https://raw.githubusercontent.com/${REPO}/main/install.sh | bash`,
+		);
+		console.log();
+		process.exit(0);
+	}
+}
+
+main();