OpenWork Development Dependencies: Complete Monorepo Package Guide

OpenWork is a pnpm workspaces monorepo where the root package.json defines build orchestration with Turbo and TypeScript, while individual packages declare granular runtime dependencies ranging from React and Zustand in the frontend to Express and Prisma in cloud services.

The different-ai/openwork repository organizes its architecture as a multi-package monorepo. To understand the full landscape of OpenWork development dependencies, you must examine both the workspace root configuration and the specific dependency trees declared in each package's package.json file across the apps/, packages/, and ee/ directories.

Root Workspace Configuration

The workspace root manages the global development environment and build pipeline. In the root package.json, the primary development dependencies include Turbo for task orchestration, TypeScript for type checking, and @types/node for Node.js type definitions. These tools are installed as devDependencies and apply to the entire monorepo.

// package.json (root)
{
  "devDependencies": {
    "turbo": "latest",
    "typescript": "^5.x",
    "@types/node": "^20.x"
  }
}

Frontend Application Dependencies

Web Application (apps/app)

The core web client is a React application built with modern state management and data fetching libraries. According to apps/app/package.json, the runtime dependencies include react and react-dom (version 18 or higher), @tanstack/react-query for server state management, and zustand for client state. The application also relies on zod for schema validation and consumes the internal @openwork/ui component library and @openwork/types for shared interfaces.

Desktop Application (apps/desktop)

The Electron-based desktop host aggregates the web application into a native wrapper. Its package.json lists dependencies on @openwork/app, @openwork/ui, and various @openwork/ee/* enterprise packages, effectively bundling the full frontend stack into a desktop distributable.

Shared Package Dependencies

UI Component Library (packages/ui)

The design system declared in packages/ui/package.json brings in visual effects through @paper-design/shaders and @paper-design/shaders-react. It declares react as a peer dependency requiring version 18 or higher, ensuring compatibility with the consuming applications while avoiding duplicate React instances.

Type System (packages/types)

Shared TypeScript definitions live in this package. The package.json specifies zod as a runtime dependency for schema definitions, with tsup and typescript handling the build process. This package is imported by nearly every other service in the monorepo to ensure type consistency across the stack.

Enterprise and Cloud Service Dependencies

Den API Services (ee/apps/den-api)

The cloud-native Den services form the backend infrastructure. The ee/apps/den-api/package.json reveals a stack built on express for HTTP handling, prisma for database ORM operations, and mysql2 as the database driver. Authentication is handled by better-auth, while cors and dotenv manage cross-origin requests and environment configuration. These services also import @openwork/types and @openwork/ee/utils for shared logic.

MCP Integration

The Model Context Protocol implementation splits client and server responsibilities:

• Client (packages/enterprise-mcp-client): Uses axios for HTTP transport, zod for message validation, and @openwork/types for shared interfaces.
• Mock Server (packages/enterprise-mcp-mock-server): Depends on express to simulate endpoints, importing the @openwork/enterprise-mcp-client for consistency.

Specialized Microservices

Several domain-specific packages extend the platform:

• Handsfree (packages/handsfree): Voice-over capabilities require the openai SDK and @openai/client, alongside internal utilities from @openwork/ee/utils.
• Email (packages/email): SMTP functionality provided by nodemailer.
• Connect Link (packages/connect-link): React-based link generation utilities depending on @openwork/types.

Testing and Evaluation Tools

The evals/ directory contains automated testing infrastructure. According to evals/package.json, the suite runs on playwright for end-to-end browser automation, ts-node for executing TypeScript scripts directly, and zod for validating test outputs against expected schemas.

Practical Usage Examples

Importing components from the UI library in a React feature:

import { Button } from '@openwork/ui/react'

export function OnboardingFlow() {
  return <Button variant="primary">Initialize Workspace</Button>
}

Calling a Den API endpoint with type safety:

import { z } from 'zod'
import { fetch } from '@openwork/ee/utils'

const OrgSchema = z.object({
  id: z.string(),
  name: z.string()
})

async function getOrganizations() {
  const response = await fetch('http://localhost:8790/api/orgs')
  const data = await response.json()
  return z.array(OrgSchema).parse(data)
}

Running the evaluation suite:

pnpm evals        # Executes Playwright E2E tests

pnpm fraimz       # Generates frame-by-frame proof evaluations

Summary

• Build System: Turbo orchestrates tasks across the pnpm workspace, with TypeScript 5.x enforcing type safety at the root level.
• Frontend Stack: React 18+ serves as the peer dependency foundation, complemented by TanStack Query for async state, Zustand for local state, and Zod for validation.
• Backend Architecture: Express.js powers microservices, with Prisma ORM managing MySQL databases via the mysql2 driver and Better Auth handling authentication.
• AI Integration: OpenAI client libraries enable voice-over features in the Handsfree package.
• Quality Assurance: Playwright drives end-to-end testing, while tsup bundles TypeScript packages for distribution.

Frequently Asked Questions

What package manager does OpenWork use?

OpenWork uses pnpm with workspaces enabled. The pnpm-workspace.yaml file defines the glob patterns for apps/*, packages/*, and ee/* directories, allowing the root lockfile to track dependencies across all sub-packages.

How do I add a dependency to a specific OpenWork package?

Navigate to the target package directory (e.g., packages/ui/) and run pnpm add <package-name>. For development-only tools, use pnpm add -D <package-name>. The root package.json should only contain workspace-wide tooling like Turbo and TypeScript.

Which database systems does OpenWork support?

The primary database stack uses Prisma with MySQL (via the mysql2 driver), as configured in ee/apps/den-api/package.json. The schema definitions in the Prisma files work alongside better-auth for identity management.

Are there peer dependencies I must install manually?

The @openwork/ui package declares react as a peer dependency requiring version 18 or higher. When consuming this package in applications like apps/app or apps/desktop, you must ensure React is installed at the application level to satisfy this requirement and avoid runtime conflicts.

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