Build Scripts Available for makeplane/plane: Complete Guide to TurboRepo Workflows

The makeplane/plane monorepo uses TurboRepo to orchestrate build scripts across multiple applications and libraries, with root-level commands like pnpm run build delegating to app-specific scripts such as react-router build for frontends and tsdown for the Live collaboration server.

Plane is an open-source project management platform structured as a monorepo managed by TurboRepo. The build scripts available for makeplane/plane are distributed across the root package.json and individual application directories, enabling both full-workspace compilation and targeted package builds.

Root Workspace Build Scripts

The top-level package.json serves as the central orchestration point for the entire monorepo. Located at the repository root, it defines TurboRepo-powered commands that execute across all packages and applications in dependency order.

The primary build scripts include:

• build – Executes turbo run build to compile all packages and applications according to the dependency graph defined in the workspace configuration.
• dev – Runs turbo run dev --concurrency=18 to start development servers for every app simultaneously with optimized parallelization.
• start – Launches production builds via turbo run start, typically invoked after the build script completes.
• clean – Removes Turbo cache, node_modules, dist folders, and other generated artifacts across the entire repository.

Additional quality assurance scripts operate at the workspace level:

• fix, fix:format, fix:lint – Auto-correct formatting and linting issues repository-wide using Turborepo.
• check, check:lint, check:format, check:types – Validate code quality without modifying files, including TypeScript type-checking across the workspace.
• prepare – Installs Husky Git hooks for pre-commit validation.
• doctor – Runs react-doctor to diagnose common React-specific issues.

Application-Specific Build Scripts

Each application in the apps/ directory maintains its own package.json with specialized build pipelines tailored to its runtime requirements.

Web UI (apps/web)

The main frontend application uses React Router's Vite-based build system. In apps/web/package.json, the scripts handle bundling and serving:

# Production build

pnpm run build        # Executes: react-router build

# Development server

pnpm run dev          # Executes: react-router dev --port 3000

# Preview built assets

pnpm run preview      # Builds then serves static files on port 3000

# Start production server

pnpm run start        # Serves build/client directory on port 3000

Admin UI (apps/admin)

The administrative interface follows an identical pattern to the Web UI but operates on port 3001. The apps/admin/package.json defines:

pnpm run build        # react-router build

pnpm run dev          # react-router dev (port 3001)

pnpm run start        # serve production build

Live Collaboration Server (apps/live)

The real-time collaboration backend uses a TypeScript compilation and bundling workflow distinct from the frontend applications. In apps/live/package.json:

# Type-check and bundle

pnpm run build        # Executes: tsc --noEmit && tsdown

# Development with hot reload

pnpm run dev          # tsdown --watch --no-clean --onSuccess "node --env-file=.env ."

# Start production server

pnpm run start        # node --env-file=.env .

The tsdown tool (an esbuild wrapper) produces the production bundle, while the --env-file=.env flag automatically loads environment variables when starting the server.

Space UI (apps/space)

The Space application provides another frontend entry point using React Router on port 3002. The apps/space/package.json contains:

pnpm run build        # react-router build

pnpm run dev          # Development server on port 3002

pnpm run start        # Production server

Library Build Scripts

Shared packages in the packages/ directory expose build scripts for compiling reusable components and utilities.

UI Component Library (packages/ui)

The shared React component library uses tsdown for bundling and includes Storybook generation. In packages/ui/package.json:

# Build component library

pnpm run build        # tsdown

# Development Storybook server

pnpm run storybook    # storybook dev -p 6006

# Static Storybook generation

pnpm run build-storybook   # storybook build

Output artifacts are written to the dist/ directory for consumption by applications.

Utilities Library (packages/utils)

Shared helper functions compile to a lightweight ESM bundle. The packages/utils/package.json defines:

pnpm run build        # tsdown

The build outputs to dist/ and serves as a dependency for multiple frontend applications.

How Build Scripts Work Together

TurboRepo coordinates execution across the monorepo using the dependency graph defined in each package's package.json. When you invoke pnpm run build from the root:

1. Dependency analysis – Turbo analyzes the dependency tree to determine build order.
2. Library compilation – Shared packages (@plane/ui, @plane/utils) execute first via tsdown in packages/ui/package.json and packages/utils/package.json.
3. Application bundling – Frontend apps (web, admin, space) invoke react-router build to create build/ directories, while the live server compiles TypeScript to a single bundled output.
4. Caching – Results are cached for subsequent incremental builds.

This architecture ensures that changes to shared libraries automatically trigger rebuilds of dependent applications while maintaining efficient caching.

Common Build Commands and Examples

Execute these commands from the repository root to interact with the build system:

# Build entire monorepo (all apps and libraries)

pnpm run build

# Build specific package only

pnpm --filter=@plane/ui run build
pnpm --filter=web run build

# Run development server for single application

pnpm --filter=web run dev        # http://localhost:3000

pnpm --filter=admin run dev      # http://localhost:3001

pnpm --filter=live run dev       # Watch mode with auto-restart

# Generate static Storybook site

pnpm --filter=@plane/ui run build-storybook

All commands use pnpm as the package manager, consistent with the repository's lockfile configuration.

Summary

• Root-level scripts in package.json orchestrate the entire monorepo via TurboRepo, with build, dev, and start as the primary entry points.
• Frontend applications (web, admin, space) use react-router build for Vite-based bundling on ports 3000-3002.
• Live collaboration server employs tsdown (esbuild-based) for TypeScript compilation with distinct build, dev, and start workflows in apps/live/package.json.
• Shared libraries (@plane/ui, @plane/utils) compile via tsdown to dist/ directories, with the UI package additionally supporting Storybook generation.
• TurboRepo caching optimizes builds by executing tasks in dependency order and reusing cached outputs when source files remain unchanged.

Frequently Asked Questions

What command builds the entire makeplane/plane repository?

Run pnpm run build from the repository root. This executes turbo run build, which coordinates the build process across all applications and libraries in the correct dependency order, ensuring shared packages compile before dependent applications.

How do I build only the Live collaboration server without building the frontend apps?

Use the filter flag: pnpm --filter=live run build. This executes only the build script defined in apps/live/package.json, which runs tsc --noEmit && tsdown to type-check and bundle the server code without touching other workspace packages.

What is the difference between the build and start scripts in makeplane/plane?

The build script compiles source code into production assets—react-router build creates static files for frontends, while tsdown generates JavaScript bundles for libraries. The start script serves these built assets, typically using serve for static files or node for the Live server, and is usually run after build completes successfully.

Which port does each application use during development?

The Web UI runs on port 3000, the Admin UI on port 3001, and the Space UI on port 3002. The Live collaboration server port is configurable via environment variables, while Storybook for the UI library runs on port 6006.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}