# Understanding the Scripts Section in package.json for OpenWork

> Unlock OpenWork's development, build, testing, and release workflows by understanding the crucial scripts section in package.json. Automate your tasks with pnpm commands.

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

---

**The `scripts` section in OpenWork's [`package.json`](https://github.com/different-ai/openwork/blob/main/package.json) serves as the central command center that automates development, build, testing, and release workflows through a collection of pnpm-accessible commands.**

The `different-ai/openwork` repository leverages its root [`package.json`](https://github.com/different-ai/openwork/blob/main/package.json) to orchestrate a complex monorepo environment. The **scripts section in package.json for OpenWork** defines standardized entry points spanning lines 13–127, enabling developers to launch services, execute evaluations, and manage deployments without memorizing intricate shell invocations. This centralized automation ensures consistent, reproducible workflows across the entire development lifecycle.

## Core Responsibilities of the Scripts Section

The `scripts` object organizes automation into five functional categories, each targeting specific phases of the development pipeline.

### Development and Local Environment Management

Development scripts provide instant access to various runtime modes. The `dev` and `dev:electron` commands launch the desktop client with `OPENWORK_DEV_MODE=1` injected for remote debugging capabilities. For backend-focused work, `dev:den` initializes the local Den API stack, while `dev:headless-web` executes [`scripts/dev-headless-web.ts`](https://github.com/different-ai/openwork/blob/main/scripts/dev-headless-web.ts) to run a headless server paired with a Vite-based interface.

### Demo and Multi-Instance Orchestration

Demo scripts create isolated testing environments with temporary profiles and dedicated ports. The `demo:electron:two` command invokes `scripts/dev-two-electron-demo.mjs` to programmatically spin up two independent Electron instances side-by-side, enabling parallel testing of administrative and consumer roles. Additional commands like `demo:den` and `demo:reset` manage mock keychains and environment state cleanup.

### Build and Release Automation

Production pipelines are triggered through `build`, `build:ui`, and the coordinated release sequence (`release:prepare`, `release:ship`). These commands delegate to dedicated Node modules such as `scripts/release/prepare.mjs` to compile TypeScript, bundle UI assets, execute version bumps, and generate changelogs prior to distribution.

### Testing and Quality Assurance

Validation workflows include `test:e2e`, `evals`, `fraimz`, and `check:diagnostics`. The `evals` script specifically targets `evals/runner/run.mjs` to execute automated end-to-end evaluation suites, while `fraimz` runs proprietary proof-generation workflows that validate the UI experience against expected behaviors.

### Utility and Maintenance Operations

Supporting infrastructure commands include `dev:sandbox` for containerized environments, `dev:worktree` for git worktree management, and `check:enterprise-mcp-mock-server` for component-specific diagnostic validation.

## Implementation Architecture

Several dedicated modules support the scripts section's functionality:

- **`scripts/dev-two-electron-demo.mjs`**: Manages dual-instance Electron orchestration, including temporary profile creation, port allocation, and process cleanup.
- **[`scripts/dev-headless-web.ts`](https://github.com/different-ai/openwork/blob/main/scripts/dev-headless-web.ts)**: Powers the headless server initialization workflow, coordinating the OpenWork backend with the Vite development server.
- **`scripts/release/prepare.mjs`**: Drives the release preparation pipeline, handling semantic versioning and documentation updates.
- **`evals/runner/run.mjs`**: Serves as the core automation engine for evaluation and fraimz testing protocols.

## Practical Usage Examples

Execute these commands from the repository root using **pnpm** (specified as `"packageManager": "pnpm@11.4.0"`):

```bash

# Launch desktop client with development debugging enabled

pnpm dev

# Run two isolated Electron demos simultaneously for side-by-side testing

pnpm demo:electron:two

# Initialize full local Den stack (API + web UI)

pnpm dev:den

# Start headless server with Vite-based web interface

pnpm dev:headless-web

# Compile production UI assets across the monorepo

pnpm build

# Execute automated evaluation suite

pnpm evals

# Prepare release with changelog generation and version review

pnpm release:prepare

```

Each command automatically injects the relevant environment variables and delegates to the underlying Node scripts defined in the **scripts section in package.json for OpenWork**, allowing developers to focus on outcomes rather than tooling invocation details.

## Summary

- The **scripts section in package.json for OpenWork** acts as the monorepo's unified command interface, eliminating manual shell complexity through standardized pnpm commands.
- Development workflows span Electron desktop (`dev:electron`), headless web servers (`dev:headless-web`), and local Den API environments (`dev:den`).
- Demo scripts leverage `scripts/dev-two-electron-demo.mjs` to create isolated multi-instance scenarios with temporary profiles and mock keychains.
- Release automation is handled through `scripts/release/prepare.mjs` and related build scripts that manage versioning and asset compilation.
- All commands execute via **pnpm** to ensure deterministic dependency resolution and workspace-aware behavior across the monorepo.

## Frequently Asked Questions

### What package manager does OpenWork use to execute scripts?

OpenWork uses **pnpm** version 11.4.0 as its package manager, as specified in the `packageManager` field of [`package.json`](https://github.com/different-ai/openwork/blob/main/package.json). This ensures deterministic lock-file behavior and proper workspace support required for the monorepo's dependency structure.

### How does the `demo:electron:two` script create isolated testing environments?

The script invokes `scripts/dev-two-electron-demo.mjs`, which programmatically generates temporary user profiles, assigns distinct network ports, and initializes mock keychains to run two independent Electron instances side-by-side. This enables parallel testing of different user roles without configuration conflicts.

### Where are the release preparation scripts located in the repository?

Release automation logic resides in `scripts/release/prepare.mjs`, which is called by the `release:prepare` npm script. This module handles version bumping, changelog generation, and pre-ship validation checks before the `release:ship` command distributes the build.

### Can I run OpenWork in headless mode without the desktop Electron interface?

Yes. The `dev:headless-web` script launches a headless OpenWork server paired with a Vite-based web UI by executing [`scripts/dev-headless-web.ts`](https://github.com/different-ai/openwork/blob/main/scripts/dev-headless-web.ts). This configuration enables browser-based interaction and API development without loading the Electron desktop shell.