# Understanding the Dependencies for OpenWork: A Complete Monorepo Breakdown

> Explore OpenWork dependencies within its pnpm workspace monorepo. Discover root tools like Turbo, runtime stacks like React and Express, and specialized libraries including OpenAI SDKs.

- Repository: [Different AI/openwork](https://github.com/different-ai/openwork)
- Tags: internals
- Published: 2026-08-01

---

**The dependencies for OpenWork are distributed across a pnpm workspace monorepo, with root-level development tools like Turbo and TypeScript, runtime stacks including React 18, Express, and Prisma in individual packages, and specialized libraries such as OpenAI SDKs and Paper-Design shaders for specific features.**

OpenWork is a multi-package monorepo organized under the `different-ai/openwork` repository, utilizing **pnpm workspaces** and **Turbo** for orchestrated builds and task caching. Understanding the dependencies for OpenWork requires examining both the root workspace configuration and the granular [`package.json`](https://github.com/different-ai/openwork/blob/main/package.json) files located across the `apps/`, `packages/`, and `ee/` directories.

## Root Workspace Dependencies

The root [`package.json`](https://github.com/different-ai/openwork/blob/main/package.json) defines the global development environment and workspace orchestration. It declares **TypeScript** as the primary language, **Turbo** for running parallel tasks and build caching, and `@types/node` for Node.js type definitions. These are development-only dependencies that support the entire monorepo infrastructure without affecting runtime bundles.

## Frontend Application Dependencies

### Web Application Stack ([`apps/app/package.json`](https://github.com/different-ai/openwork/blob/main/apps/app/package.json))

The core web application runs on **React 18** (with React 19 compatibility) and utilizes **Next.js** architectural patterns. State management relies on `@tanstack/react-query` for server-state synchronization and `zustand` for client-side stores. Data validation throughout the app uses `zod`, while the UI layer consumes the internal `@openwork/ui` package alongside **Shadcn UI** preset components.

### Desktop Host ([`apps/desktop/package.json`](https://github.com/different-ai/openwork/blob/main/apps/desktop/package.json))

The Electron-based desktop application acts as a native container that aggregates dependencies from `@openwork/app`, `@openwork/ui`, and various `@openwork/ee/*` enterprise packages. Rather than defining duplicate dependencies, it inherits the web stack through internal package references while adding Electron-specific tooling for window management and native API access.

## Shared Library Dependencies

### UI Component Library ([`packages/ui/package.json`](https://github.com/different-ai/openwork/blob/main/packages/ui/package.json))

The `@openwork/ui` package provides reusable visual components with runtime dependencies on `@paper-design/shaders` and `@paper-design/shaders-react` for advanced WebGL visual effects. It declares **React** as a peer dependency requiring version 18 or higher, ensuring compatibility with the consuming applications without bundling duplicate React instances.

### Type System ([`packages/types/package.json`](https://github.com/different-ai/openwork/blob/main/packages/types/package.json))

Centralized TypeScript definitions and schemas depend on `zod` for runtime validation and type inference. The build pipeline uses `tsup` for fast bundling of TypeScript declarations, with `typescript` as a development dependency for compilation.

## Enterprise and Cloud Service Dependencies

### Den Microservices ([`ee/apps/den-api/package.json`](https://github.com/different-ai/openwork/blob/main/ee/apps/den-api/package.json))

The cloud infrastructure layer implements **Express** for HTTP request handling and **Prisma** ORM with `mysql2` drivers for MySQL database connectivity. Authentication services utilize `better-auth` with `cors` middleware for cross-origin resource sharing. Configuration management relies on `dotenv`, while shared logic imports from `@openwork/types` and `@openwork/ee/utils`.

### MCP Integration Layer

The Model Context Protocol (MCP) implementation spans two packages:

- **Enterprise MCP Client** ([`packages/enterprise-mcp-client/package.json`](https://github.com/different-ai/openwork/blob/main/packages/enterprise-mcp-client/package.json)): Uses `axios` for HTTP transport, `zod` for request/response validation, and `@openwork/types` for shared interfaces.
- **Enterprise MCP Mock Server** ([`packages/enterprise-mcp-mock-server/package.json`](https://github.com/different-ai/openwork/blob/main/packages/enterprise-mcp-mock-server/package.json)): Runs on `express` with dependencies on the enterprise MCP client and `zod` for protocol testing and development.

## Utility and Integration Packages

### Handsfree Voice Operations ([`packages/handsfree/package.json`](https://github.com/different-ai/openwork/blob/main/packages/handsfree/package.json))

Voice-over and audio processing capabilities depend on the `openai` SDK and `@openai/client` for speech-to-text and text-to-text operations, integrated with internal `@openwork/types` and `@openwork/ee/utils` for data structures.

### Email Delivery ([`packages/email/package.json`](https://github.com/different-ai/openwork/blob/main/packages/email/package.json))

The email service handles SMTP operations through `nodemailer`, using `@openwork/types` for message schema definitions and type safety across the sending pipeline.

### Connect Link Generator ([`packages/connect-link/package.json`](https://github.com/different-ai/openwork/blob/main/packages/connect-link/package.json))

This utility package provides React-based link generation components with minimal dependencies on `react` and `@openwork/types` for configuration interfaces.

## Development and Testing Infrastructure ([`evals/package.json`](https://github.com/different-ai/openwork/blob/main/evals/package.json))

The automated evaluation framework uses **Playwright** for end-to-end browser testing and `ts-node` for executing TypeScript evaluation scripts without pre-compilation. It shares `zod` for test data validation and includes custom utilities for generating "fraimz" proofs during automated assessments.

## Implementation Examples

Consuming the UI library in a React component:

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

export function MyComponent() {
  return <Button onClick={() => console.log('OpenWork UI')}>Execute</Button>
}

```

Querying the Den API from a desktop client:

```typescript
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 OrgSchema.array().parse(data)
}

```

Running the evaluation suite:

```bash
pnpm evals
pnpm fraimz

```

## Summary

- **Root workspace** uses Turbo, TypeScript, and Node types for development orchestration and task caching.
- **Web applications** depend on React 18+, TanStack Query, Zustand, and Zod for state management and validation.
- **UI layer** integrates Paper-Design shaders with Shadcn UI component presets via the internal `@openwork/ui` package.
- **Backend services** run Express with Prisma ORM, Better-Auth, and MySQL2 drivers for database operations.
- **Enterprise features** include MCP clients using Axios and OpenAI SDKs for voice processing and AI integrations.
- **Testing infrastructure** relies on Playwright and custom evaluation frameworks located in the `evals/` directory.

## Frequently Asked Questions

### What package manager does OpenWork use?

OpenWork uses **pnpm** workspaces to manage the monorepo structure, enabling efficient dependency deduplication and isolated node_modules across the `apps/`, `packages/`, and `ee/` directories while maintaining fast installation speeds.

### Which database technology does OpenWork use for its cloud services?

According to [`ee/apps/den-api/package.json`](https://github.com/different-ai/openwork/blob/main/ee/apps/den-api/package.json), the Den microservices use **Prisma** as the ORM with **MySQL** (via the `mysql2` driver) as the underlying database, alongside `better-auth` for authentication handling.

### How are UI components shared between the web and desktop applications?

The `@openwork/ui` package, defined in [`packages/ui/package.json`](https://github.com/different-ai/openwork/blob/main/packages/ui/package.json), distributes components using **React** as a peer dependency and includes **Paper-Design shaders** for visual effects. Both the web app (`apps/app`) and desktop app (`apps/desktop`) consume this package to ensure UI consistency.

### What testing tools are included in the OpenWork dependencies?

The [`evals/package.json`](https://github.com/different-ai/openwork/blob/main/evals/package.json) specifies **Playwright** for end-to-end testing, `ts-node` for TypeScript execution, and `zod` for validation within test suites, alongside custom "fraimz" utilities for frame-by-frame proof generation during automated evaluations.