Understanding the Scripts Section in package.json for OpenWork

The scripts section in OpenWork's 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 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 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: 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"):

# 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. 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. This configuration enables browser-based interaction and API development without loading the Electron desktop shell.

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