ifeq (,$(filter -j%,$(MAKEFLAGS)))

MAKEFLAGS += -j

include fmt.mk

.PHONY: all build dev start clean help

.PHONY: build-renderer version build-icons build-static

.PHONY: lint lint-fix typecheck static-check

.PHONY: test test-unit test-integration test-watch test-coverage test-e2e

.PHONY: dist dist-mac dist-win dist-linux

.PHONY: vscode-ext vscode-ext-install

.PHONY: docs docs-build docs-watch

.PHONY: storybook storybook-build test-storybook chromatic

.PHONY: benchmark-terminal

.PHONY: ensure-deps

.PHONY: check-eager-imports check-bundle-size check-startup

TSGO := bun run node_modules/@typescript/native-preview/bin/tsgo.js

REQUIRED_NODE_VERSION := 20

NODE_VERSION := $(shell node --version | sed 's/v\([0-9]*\).*/\1/')

define check_node_version

@if [ "$(NODE_VERSION)" -lt "$(REQUIRED_NODE_VERSION)" ]; then \

echo "Error: Node.js v$(REQUIRED_NODE_VERSION) or higher is required"; \

echo "Current version: v$(NODE_VERSION)"; \

echo ""; \

echo "To upgrade Node.js:"; \

echo " 1. Install 'n' version manager: curl -L https://raw.githubusercontent.com/tj/n/master/bin/n | sudo bash -s -- lts"; \

echo " 2. Or use 'n' if already installed: sudo n $(REQUIRED_NODE_VERSION)"; \

echo ""; \

exit 1; \

fi

HAS_BROWSER_OPENER := $(shell command -v xdg-open >/dev/null 2>&1 && echo "yes" || echo "no")

STORYBOOK_OPEN_FLAG := $(if $(filter yes,$(HAS_BROWSER_OPENER)),,--no-open)

TS_SOURCES := $(shell find src -type f \( -name '*.ts' -o -name '*.tsx' \))

all: build

node_modules/.installed: package.json bun.lock

@echo "Dependencies out of date or missing, running bun install..."

@bun install

@touch node_modules/.installed

ensure-deps: node_modules/.installed

help: ## Show this help message

@echo 'Usage: make [target]'

@echo ''

@echo 'Available targets:'

@grep -E '^[a-zA-Z_-]+:.*?## .*$$' $(MAKEFILE_LIST) | sort | awk 'BEGIN {FS = ":.*?## "}; {printf " \033[36m%-20s\033[0m %s\n", $$1, $$2}'

dev: node_modules/.installed build-main ## Start development server (Vite + tsgo watcher for 10x faster type checking)

@bun x concurrently -k \

"bun x concurrently \"$(TSGO) -w -p tsconfig.main.json\" \"bun x tsc-alias -w -p tsconfig.main.json\"" \

"vite"

dev-server: node_modules/.installed build-main ## Start server mode with hot reload (backend :3000 + frontend :5173). Use VITE_HOST=0.0.0.0 BACKEND_HOST=0.0.0.0 for remote access

@echo "Starting dev-server..."

@echo " Backend (IPC/WebSocket): http://$(or $(BACKEND_HOST),localhost):$(or $(BACKEND_PORT),3000)"

@echo " Frontend (with HMR): http://$(or $(VITE_HOST),localhost):$(or $(VITE_PORT),5173)"

@echo ""

@echo "For remote access: make dev-server VITE_HOST=0.0.0.0 BACKEND_HOST=0.0.0.0"

@bun x concurrently -k \

"bun x concurrently \"$(TSGO) -w -p tsconfig.main.json\" \"bun x tsc-alias -w -p tsconfig.main.json\"" \

"bun x nodemon --watch dist/main.js --watch dist/main-server.js --delay 500ms --exec 'NODE_ENV=development node dist/main.js server --host $(or $(BACKEND_HOST),localhost) --port $(or $(BACKEND_PORT),3000)'" \

"MUX_VITE_HOST=$(or $(VITE_HOST),127.0.0.1) MUX_VITE_PORT=$(or $(VITE_PORT),5173) VITE_BACKEND_URL=http://$(or $(BACKEND_HOST),localhost):$(or $(BACKEND_PORT),3000) vite"

start: node_modules/.installed build-main build-preload build-static ## Build and start Electron app

@NODE_ENV=development bun x electron --remote-debugging-port=9222 .

build: node_modules/.installed src/version.ts build-renderer build-main build-preload build-icons build-static ## Build all targets

build-main: node_modules/.installed dist/main.js ## Build main process

dist/main.js: src/version.ts tsconfig.main.json tsconfig.json $(TS_SOURCES)

@echo "Building main process..."

@NODE_ENV=production $(TSGO) -p tsconfig.main.json

@NODE_ENV=production bun x tsc-alias -p tsconfig.main.json

build-preload: node_modules/.installed dist/preload.js ## Build preload script

dist/preload.js: src/preload.ts $(TS_SOURCES)

@echo "Building preload script..."

@NODE_ENV=production bun build src/preload.ts \

--format=cjs \

--target=node \

--external=electron \

--sourcemap=inline \

--outfile=dist/preload.js

build-renderer: node_modules/.installed src/version.ts ## Build renderer process

@echo "Building renderer..."

@bun x vite build

build-static: ## Copy static assets to dist

@echo "Copying static assets..."

@mkdir -p dist

@cp static/splash.html dist/splash.html

@cp -r public/* dist/

version: ## Generate version file

@./scripts/generate-version.sh

src/version.ts: version

ifeq ($(shell uname), Darwin)

build-icons: build/icon.icns build/icon.png ## Generate Electron app icons from logo (macOS builds both)

build-icons: build/icon.png ## Generate Electron app icons from logo (Linux builds PNG only)

MAGICK_CMD := $(shell command -v magick 2>/dev/null || command -v convert 2>/dev/null || echo "magick")

build/icon.png: docs/img/logo.webp

@echo "Generating Linux icon..."

@mkdir -p build

@$(MAGICK_CMD) docs/img/logo.webp -resize 512x512 build/icon.png

build/icon.icns: docs/img/logo.webp

@echo "Generating macOS icon..."

@mkdir -p build/icon.iconset

@for size in 16 32 64 128 256 512; do \

$(MAGICK_CMD) docs/img/logo.webp -resize $${size}x$${size} build/icon.iconset/icon_$${size}x$${size}.png; \

if [ $$size -le 256 ]; then \

double=$$((size * 2)); \

$(MAGICK_CMD) docs/img/logo.webp -resize $${double}x$${double} build/icon.iconset/icon_$${size}x$${size}@2x.png; \

fi; \

done

@iconutil -c icns build/icon.iconset -o build/icon.icns

@rm -rf build/icon.iconset

static-check: lint typecheck fmt-check check-eager-imports ## Run all static checks (includes startup performance checks)

lint: node_modules/.installed ## Run ESLint (typecheck runs in separate target)

@./scripts/lint.sh

lint-fix: node_modules/.installed ## Run linter with --fix

@./scripts/lint.sh --fix

typecheck: node_modules/.installed src/version.ts ## Run TypeScript type checking (uses tsgo for 10x speedup)

@bun x concurrently -g \

"$(TSGO) --noEmit" \

"$(TSGO) --noEmit -p tsconfig.main.json"

check-deadcode: node_modules/.installed ## Check for potential dead code (manual only, not in static-check)

@echo "Checking for potential dead code with ts-prune..."

@echo "(Note: Some unused exports are legitimate - types, public APIs, entry points, etc.)"

@echo ""

@bun x ts-prune -i '(test|spec|mock|bench|debug|storybook)' \

| grep -v "used in module" \

| grep -v "src/App.tsx.*default" \

| grep -v "src/types/" \

| grep -v "telemetry/index.ts" \

|| echo "✓ No obvious dead code found"

test-integration: node_modules/.installed build-main ## Run all tests (unit + integration)

@bun test src

@TEST_INTEGRATION=1 bun x jest tests

test-unit: node_modules/.installed build-main ## Run unit tests

@bun test src

test: test-unit ## Alias for test-unit

test-watch: ## Run tests in watch mode

@./scripts/test.sh --watch

test-coverage: ## Run tests with coverage

@./scripts/test.sh --coverage

test-e2e: ## Run end-to-end tests

@$(MAKE) build

@MUX_E2E_LOAD_DIST=1 MUX_E2E_SKIP_BUILD=1 PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD=1 bun x playwright test --project=electron $(PLAYWRIGHT_ARGS)

dist: build ## Build distributable packages

@bun x electron-builder --publish never

dist-mac: build ## Build macOS distributables (x64 + arm64)

@if [ -n "$$CSC_LINK" ]; then \

echo "🔐 Code signing enabled - building sequentially to avoid keychain conflicts..."; \

bun x electron-builder --mac --x64 --publish never && \

bun x electron-builder --mac --arm64 --publish never; \

else \

echo "Building macOS architectures in parallel..."; \

bun x electron-builder --mac --x64 --publish never & pid1=$$! ; \

bun x electron-builder --mac --arm64 --publish never & pid2=$$! ; \

wait $$pid1 && wait $$pid2; \

fi

@echo "✅ Both architectures built successfully"

dist-mac-release: build ## Build and publish macOS distributables (x64 + arm64)

@if [ -n "$$CSC_LINK" ]; then \

echo "🔐 Code signing enabled - building sequentially to avoid keychain conflicts..."; \

bun x electron-builder --mac --x64 --publish always && \

bun x electron-builder --mac --arm64 --publish always; \

else \

echo "Building and publishing macOS architectures in parallel..."; \

bun x electron-builder --mac --x64 --publish always & pid1=$$! ; \

bun x electron-builder --mac --arm64 --publish always & pid2=$$! ; \

wait $$pid1 && wait $$pid2; \

fi

@echo "✅ Both architectures built and published successfully"

dist-mac-x64: build ## Build macOS x64 distributable only

@echo "Building macOS x64..."

@bun x electron-builder --mac --x64 --publish never

dist-mac-arm64: build ## Build macOS arm64 distributable only

@echo "Building macOS arm64..."

@bun x electron-builder --mac --arm64 --publish never

dist-win: build ## Build Windows distributable

@bun x electron-builder --win --publish never

dist-linux: build ## Build Linux distributable

@bun x electron-builder --linux --publish never

vscode-ext: ## Build VS Code extension (.vsix)

@$(MAKE) -C vscode build

vscode-ext-install: ## Build and install VS Code extension locally

@$(MAKE) -C vscode install

docs: ## Serve documentation locally

@./scripts/docs.sh

docs-build: ## Build documentation

@./scripts/docs_build.sh

docs-watch: ## Watch and rebuild documentation

@cd docs && mdbook watch

storybook: node_modules/.installed ## Start Storybook development server

$(check_node_version)

@bun x storybook dev -p 6006 $(STORYBOOK_OPEN_FLAG)

storybook-build: node_modules/.installed src/version.ts ## Build static Storybook

$(check_node_version)

@bun x storybook build

test-storybook: node_modules/.installed ## Run Storybook interaction tests (requires Storybook to be running or built)

$(check_node_version)

@bun x test-storybook

chromatic: node_modules/.installed ## Run Chromatic for visual regression testing

$(check_node_version)

@bun x chromatic --exit-zero-on-changes

benchmark-terminal: ## Run Terminal-Bench with the mux agent (use TB_DATASET/TB_SAMPLE_SIZE/TB_TIMEOUT/TB_ARGS to customize)

@TB_DATASET=$${TB_DATASET:-terminal-bench-core==0.1.1}; \

TB_TIMEOUT=$${TB_TIMEOUT:-1800}; \

CONCURRENCY_FLAG=$${TB_CONCURRENCY:+--n-concurrent $$TB_CONCURRENCY}; \

LIVESTREAM_FLAG=$${TB_LIVESTREAM:+--livestream}; \

TASK_ID_FLAGS=""; \

if [ -n "$$TB_SAMPLE_SIZE" ]; then \

echo "Ensuring dataset $$TB_DATASET is downloaded..."; \

uvx terminal-bench datasets download --dataset "$$TB_DATASET" 2>&1 | grep -v "already exists" || true; \

echo "Sampling $$TB_SAMPLE_SIZE tasks from $$TB_DATASET..."; \

TASK_IDS=$$(python3 benchmarks/terminal_bench/sample_tasks.py --dataset "$$TB_DATASET" --sample-size "$$TB_SAMPLE_SIZE" --format space) || { \

echo "Error: Failed to sample tasks" >&2; \

exit 1; \

}; \

if [ -z "$$TASK_IDS" ]; then \

echo "Error: Sampling returned no task IDs" >&2; \

exit 1; \

fi; \

for task_id in $$TASK_IDS; do \

TASK_ID_FLAGS="$$TASK_ID_FLAGS --task-id $$task_id"; \

done; \

echo "Selected task IDs: $$TASK_IDS"; \

fi; \

echo "Using timeout: $$TB_TIMEOUT seconds"; \

echo "Running Terminal-Bench with dataset $$TB_DATASET"; \

export MUX_TIMEOUT_MS=$$((TB_TIMEOUT * 1000)); \

uvx terminal-bench run \

--dataset "$$TB_DATASET" \

--agent-import-path benchmarks.terminal_bench.mux_agent:CmuxAgent \

--global-agent-timeout-sec $$TB_TIMEOUT \

$$CONCURRENCY_FLAG \

$$LIVESTREAM_FLAG \

$$TASK_ID_FLAGS \

$${TB_ARGS}

clean: ## Clean build artifacts

@echo "Cleaning build artifacts..."

@rm -rf dist release build/icon.icns build/icon.png

@echo "Done!"

check-eager-imports: ## Check for eager AI SDK imports in critical files

@./scripts/check_eager_imports.sh

check-bundle-size: build ## Check that bundle sizes are within limits

@./scripts/check_bundle_size.sh

check-startup: check-eager-imports check-bundle-size ## Run all startup performance checks

.NOTPARALLEL: build-main # TypeScript can handle its own parallelism