Understanding the Dependencies for OpenWork: A Complete Monorepo Breakdown

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 files located across the apps/, packages/, and ee/ directories.

Root Workspace Dependencies

The root 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)

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)

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)

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)

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)

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): 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): 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)

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)

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)

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)

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:

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:

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:

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, 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, 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 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.

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