@tomagranate/toolui 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 toolui 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,225 @@
+# ToolUI
+
+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 ToolUI?
+
+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. ToolUI 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/toolui/toolui
+```
+
+### NPM
+
+```bash
+npm install -g @tomagranate/toolui
+```
+
+### curl (macOS and Linux)
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/tomagranate/toolui/main/install.sh | bash
+```
+
+### Manual Download
+
+Download the latest binary for your platform from [Releases](https://github.com/tomagranate/toolui/releases).
+
+| Platform | Download |
+|----------|----------|
+| macOS (Apple Silicon) | `toolui-darwin-arm64.tar.gz` |
+| macOS (Intel) | `toolui-darwin-x64.tar.gz` |
+| Linux (x64) | `toolui-linux-x64.tar.gz` |
+| Linux (ARM64) | `toolui-linux-arm64.tar.gz` |
+| Windows (x64) | `toolui-windows-x64.zip` |
+
+## Quick Start
+
+1. Create a config file in your project:
+
+```bash
+toolui init
+```
+
+2. Edit `toolui.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
+toolui
+```
+
+## CLI Reference
+
+### Commands
+
+| Command | Description |
+|---------|-------------|
+| `toolui` | Start the TUI dashboard |
+| `toolui init` | Create a sample config file in the current directory |
+| `toolui mcp` | Start the MCP server for AI agent integration |
+
+### Options
+
+| Option | Description |
+|--------|-------------|
+| `-c, --config <path>` | Path to config file (default: `toolui.config.toml`) |
+| `-h, --help` | Show help message |
+
+### Examples
+
+```bash
+# Start with default config
+toolui
+
+# Use a custom config file
+toolui --config ./configs/dev.toml
+toolui -c ./configs/dev.toml
+
+# Create a new config file
+toolui init
+
+# Start MCP server for AI integration
+toolui mcp
+```
+
+## Configuration
+
+ToolUI is configured via a TOML file. By default, it looks for `toolui.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
+
+ToolUI 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
+
+ToolUI 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": {
+    "toolui": {
+      "command": "toolui",
+      "args": ["mcp"]
+    }
+  }
+}
+```
+
+### Available MCP Tools
+
+| Tool | Description |
+|------|-------------|
+| `list_processes` | List all processes with their status |
+| `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 |
+
+## Contributing
+
+See the [Contributing Guide](CONTRIBUTING.md) for development setup and guidelines.
+
+## License
+
+MIT

package/bin/toolui

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+
+const { spawn } = require("child_process");
+const { existsSync } = require("fs");
+const { join, dirname } = require("path");
+
+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 = `toolui-${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 toolui");
+	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 toolui: ${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,65 @@
+{
+	"name": "@tomagranate/toolui",
+	"version": "0.1.0",
+	"description": "A Terminal User Interface (TUI) for running multiple local development servers and tools simultaneously",
+	"type": "module",
+	"bin": {
+		"toolui": "bin/toolui"
+	},
+	"files": [
+		"bin",
+		"scripts"
+	],
+	"scripts": {
+		"dev": "bun run src/index.tsx",
+		"build": "bun build src/index.tsx --compile --minify --outfile dist/toolui",
+		"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/toolui.git"
+	},
+	"homepage": "https://github.com/tomagranate/toolui#readme",
+	"bugs": {
+		"url": "https://github.com/tomagranate/toolui/issues"
+	},
+	"engines": {
+		"node": ">=18.0.0"
+	},
+	"devDependencies": {
+		"@biomejs/biome": "^2.3.11",
+		"@types/bun": "latest"
+	},
+	"peerDependencies": {
+		"typescript": "^5.9.3"
+	},
+	"dependencies": {
+		"@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"
+	}
+}

package/scripts/build-all.ts

@@ -0,0 +1,81 @@
+#!/usr/bin/env bun
+
+/**
+ * Build toolui 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 = `toolui-${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 toolui 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,219 @@
+#!/usr/bin/env node
+
+/**
+ * Postinstall script for toolui NPM package.
+ * Downloads the appropriate binary for the current platform.
+ */
+
+const https = require("node:https");
+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/toolui";
+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",
+};
+
+/**
+ * Make an HTTPS GET request
+ */
+function httpsGet(url, options = {}) {
+	return new Promise((resolve, reject) => {
+		const opts = {
+			...options,
+			headers: {
+				"User-Agent": "toolui-postinstall",
+				...options.headers,
+			},
+		};
+
+		https
+			.get(url, opts, (res) => {
+				// Handle redirects
+				if (
+					res.statusCode >= 300 &&
+					res.statusCode < 400 &&
+					res.headers.location
+				) {
+					return httpsGet(res.headers.location, options)
+						.then(resolve)
+						.catch(reject);
+				}
+
+				if (res.statusCode !== 200) {
+					reject(new Error(`HTTP ${res.statusCode}: ${url}`));
+					return;
+				}
+
+				const chunks = [];
+				res.on("data", (chunk) => chunks.push(chunk));
+				res.on("end", () => resolve(Buffer.concat(chunks)));
+				res.on("error", reject);
+			})
+			.on("error", reject);
+	});
+}
+
+/**
+ * Get the version from package.json
+ */
+function getVersion() {
+	const packageJson = JSON.parse(
+		fs.readFileSync(path.join(__dirname, "..", "package.json"), "utf-8"),
+	);
+	return packageJson.version;
+}
+
+/**
+ * Download and extract the binary
+ */
+async function downloadBinary(url, destPath) {
+	console.log(`Downloading from ${url}...`);
+	const data = await httpsGet(url);
+
+	// Extract tar.gz
+	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);
+			// Simple tar extraction - find the file content
+			// tar format: 512-byte header blocks followed by file content
+			let offset = 0;
+			while (offset < tarData.length) {
+				const header = tarData.slice(offset, offset + 512);
+				if (header[0] === 0) break; // End of archive
+
+				// Get filename (bytes 0-99)
+				const filename = header
+					.slice(0, 100)
+					.toString("utf-8")
+					.replace(/\0/g, "");
+
+				// Get file size (bytes 124-135, octal)
+				const sizeStr = header
+					.slice(124, 136)
+					.toString("utf-8")
+					.replace(/\0/g, "")
+					.trim();
+				const size = parseInt(sizeStr, 8) || 0;
+
+				offset += 512; // Move past header
+
+				if (filename && size > 0 && filename.startsWith("toolui")) {
+					const content = tarData.slice(offset, offset + size);
+					fs.writeFileSync(destPath, content);
+					fs.chmodSync(destPath, 0o755);
+					resolve();
+					return;
+				}
+
+				// Move to next file (content is padded to 512-byte blocks)
+				offset += Math.ceil(size / 512) * 512;
+			}
+			reject(new Error("Could not find toolui binary in archive"));
+		});
+		gunzip.on("error", reject);
+
+		gunzip.end(data);
+	});
+}
+
+/**
+ * Download Windows zip and extract
+ */
+async function downloadWindowsBinary(url, destPath) {
+	console.log(`Downloading from ${url}...`);
+	const data = await httpsGet(url);
+
+	// Write zip to temp file
+	const zipPath = `${destPath}.zip`;
+	fs.writeFileSync(zipPath, data);
+
+	// Use unzip if available, otherwise try PowerShell
+	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);
+	}
+}
+
+async function main() {
+	const platform = PLATFORM_MAP[process.platform];
+	const arch = ARCH_MAP[process.arch];
+
+	if (!platform || !arch) {
+		console.log(`Unsupported platform: ${process.platform}-${process.arch}`);
+		console.log("You may need to build from source or download manually.");
+		process.exit(0); // Don't fail installation
+	}
+
+	const version = getVersion();
+	const binaryName = `toolui-${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(`Binary already exists: ${destPath}`);
+		return;
+	}
+
+	// Ensure bin directory exists
+	if (!fs.existsSync(binDir)) {
+		fs.mkdirSync(binDir, { recursive: true });
+	}
+
+	const archiveExt = platform === "windows" ? "zip" : "tar.gz";
+	const downloadUrl = `${GITHUB_RELEASES}/download/v${version}/${binaryName}.${archiveExt}`;
+
+	try {
+		if (platform === "windows") {
+			await downloadWindowsBinary(downloadUrl, destPath);
+		} else {
+			await downloadBinary(downloadUrl, destPath);
+		}
+		console.log(`Successfully installed toolui binary to ${destPath}`);
+	} catch (error) {
+		console.error(`Failed to download binary: ${error.message}`);
+		console.error("");
+		console.error("You can manually download the binary from:");
+		console.error(`  ${GITHUB_RELEASES}/latest`);
+		console.error("");
+		console.error("Or install via the install script:");
+		console.error(
+			`  curl -fsSL https://raw.githubusercontent.com/${REPO}/main/install.sh | bash`,
+		);
+		// Don't fail the install - the user can still use the package
+		process.exit(0);
+	}
+}
+
+main();