English | 中文

OpenClaw is a powerful agent runtime — but it's built for engineers. Setting it up means editing config files, managing processes, and juggling API keys from the terminal. For non-programmers (designers, operators, small business owners), that barrier is too high.

EasyClaw wraps OpenClaw into a desktop app that anyone can use: install, launch from the system tray, and manage everything through a local web panel. Write rules in plain language instead of code, configure LLM providers and messaging channels with a few clicks, and let the agent learn your preferences over time. No terminal required.

In short: OpenClaw is the engine; EasyClaw is the cockpit.

• Natural Language Rules: Write rules in plain language—they compile to policy, guards, or skills and take effect immediately (no restart)
• Multi-Provider LLM Support: 17+ providers (OpenAI, Anthropic, Google Gemini, DeepSeek, Zhipu/Z.ai, Moonshot, Qwen, Groq, Mistral, xAI, OpenRouter, MiniMax, Venice AI, Xiaomi, Volcengine/Doubao, Amazon Bedrock, etc.) with multi-key management and region-aware defaults
• Gemini CLI OAuth: Sign in with Google for free-tier Gemini access—no API key needed. Auto-detects or installs Gemini CLI credentials
• Per-Provider Proxy Support: Configure HTTP/SOCKS5 proxies per LLM provider or API key, with automatic routing and hot reload—essential for restricted regions
• WeChat Messaging (WeCom): Chat with your agent from WeChat via a WeCom Customer Service relay. Open-source relay server included (apps/wecom-relay)
• Multi-Account Channels: Configure Telegram, Discord, Slack, WhatsApp, DingTalk, and more through UI with secure secret storage (Keychain/DPAPI)
• Token Usage Tracking: Real-time statistics by model and provider, auto-refreshed from OpenClaw session files
• Speech-to-Text: Region-aware STT integration for voice messages (Groq, Volcengine)
• Visual Permissions: Control file read/write access through UI
• Zero-Restart Updates: API key, proxy, and channel changes apply instantly via hot reload—no gateway restart needed
• Local-First & Private: All data stays on your machine; secrets never stored in plaintext
• Auto-Update: Client update checker with static manifest hosting
• Privacy-First Telemetry: Optional anonymous usage analytics—no PII collected

EasyClaw enforces file access permissions through an OpenClaw plugin that intercepts tool calls before they execute. Here's what's protected:

• File access tools (read, write, edit, image, apply-patch): Fully protected—paths are validated against your configured permissions
• Command execution (exec, process): Working directory is validated, but paths inside command strings (like cat /etc/passwd) cannot be inspected

Coverage: ~85-90% of file access scenarios. For maximum security, consider restricting or disabling exec tools through Rules.

Technical note: The file permissions plugin uses OpenClaw's before_tool_call hook—no vendor source code modifications needed, so EasyClaw can cleanly pull upstream OpenClaw updates.

# 1. Clone and build the vendored OpenClaw runtime
./scripts/setup-vendor.sh

# 2. Install workspace dependencies and build
pnpm install
pnpm build

# 3. Launch in dev mode
pnpm --filter @easyclaw/desktop dev

This starts the Electron tray app, which spawns the OpenClaw gateway and serves the management panel at http://localhost:3210.

easyclaw/
├── apps/
│   ├── desktop/          # Electron tray app (main process)
│   ├── panel/            # React management UI (served by desktop)
│   └── wecom-relay/      # WeCom Customer Service relay server (self-hosted)
├── packages/
│   ├── core/             # Shared types & Zod schemas
│   ├── device-id/        # Machine fingerprinting for device identity
│   ├── gateway/          # Gateway lifecycle, config writer, secret injection, OAuth flows
│   ├── logger/           # Structured logging (tslog)
│   ├── storage/          # SQLite persistence (better-sqlite3)
│   ├── rules/            # Rule compilation & skill file writer
│   ├── secrets/          # Keychain / DPAPI / file-based secret stores
│   ├── updater/          # Auto-update client
│   ├── stt/              # Speech-to-text abstraction (Groq, Volcengine)
│   ├── proxy-router/     # HTTP CONNECT proxy multiplexer for restricted regions
│   ├── telemetry/        # Privacy-first anonymous analytics client
│   ├── file-permissions-plugin/  # OpenClaw plugin for file access control
│   └── openclaw-plugin/  # OpenClaw plugin SDK
├── extensions/
│   ├── dingtalk/         # DingTalk channel integration
│   └── wecom/            # WeCom channel plugin (runs inside gateway)
├── scripts/
│   ├── release-local.sh  # Local release pipeline (build, test, upload)
│   └── rebuild-native.sh # Prebuild better-sqlite3 for Node.js + Electron
├── vendor/
│   └── openclaw/         # Vendored OpenClaw binary (gitignored)
└── website/              # Static site + nginx/docker for hosting releases

The monorepo uses pnpm workspaces (apps/*, packages/*, extensions/*) with Turbo for build orchestration. All packages produce ESM output via tsdown.

Most root scripts run through Turbo:

pnpm build        # Build all packages (respects dependency graph)
pnpm dev          # Run desktop + panel in dev mode
pnpm test         # Run all tests (vitest)
pnpm lint         # Lint all packages (oxlint)
pnpm format       # Check formatting (oxfmt, runs directly)
pnpm format:fix   # Auto-fix formatting (oxfmt, runs directly)

# Desktop
pnpm --filter @easyclaw/desktop dev        # Launch Electron in dev mode
pnpm --filter @easyclaw/desktop build      # Bundle main process
pnpm --filter @easyclaw/desktop test       # Run desktop tests
pnpm --filter @easyclaw/desktop dist:mac   # Build macOS DMG (universal)
pnpm --filter @easyclaw/desktop dist:win   # Build Windows NSIS installer

# Panel
pnpm --filter @easyclaw/panel dev          # Vite dev server
pnpm --filter @easyclaw/panel build        # Production build

# Any package
pnpm --filter @easyclaw/core test
pnpm --filter @easyclaw/gateway test

┌─────────────────────────────────────────┐
│  System Tray (Electron main process)    │
│  ├── GatewayLauncher → vendor/openclaw  │
│  ├── Panel HTTP Server (:3210)          │
│  │   ├── Static files (panel dist/)     │
│  │   └── REST API (/api/*)              │
│  ├── SQLite Storage                     │
│  ├── Auth Profile Sync                  │
│  └── Auto-Updater                       │
└─────────────────────────────────────────┘
         │                    ▲
         ▼                    │
┌─────────────┐    ┌─────────────────┐
│  OpenClaw   │    │  Panel (React)  │
│  Gateway    │    │  localhost:3210  │
│  Process    │    └─────────────────┘
└─────────────┘
         │ (extensions/wecom plugin via WebSocket)
         ▼
┌──────────────────────┐      ┌────────────┐
│  WeCom Relay Server  │◄─────│  WeChat    │
│  (apps/wecom-relay)  │      │  Users     │
└──────────────────────┘      └────────────┘

The desktop app runs as a tray-only application (hidden from the dock on macOS). It:

1. Spawns the OpenClaw gateway from vendor/openclaw/
2. Serves the panel UI and REST API on localhost:3210
3. Writes gateway config and auth profiles to ~/.openclaw/
4. Injects secrets (API keys + OAuth tokens) from the system keychain at runtime
5. Watches ~/.openclaw/skills/ for hot-reload of rule-generated skill files
6. Syncs refreshed OAuth tokens back to keychain on shutdown

The panel server exposes these endpoints:

The dist:mac and dist:win scripts automatically prune vendor/openclaw/node_modules to production-only dependencies before packaging. This reduces the DMG from ~360MB to ~270MB.

After building, vendor node_modules will be pruned. To restore full deps for development:

cd vendor/openclaw && CI=true pnpm install --no-frozen-lockfile && cd ../..

pnpm build
pnpm --filter @easyclaw/desktop dist:mac
# Output: apps/desktop/release/EasyClaw-<version>-universal.dmg

For code signing and notarization, set these environment variables:

CSC_LINK=<path-to-.p12-certificate>
CSC_KEY_PASSWORD=<certificate-password>
APPLE_ID=<your-apple-id>
APPLE_APP_SPECIFIC_PASSWORD=<app-specific-password>
APPLE_TEAM_ID=<team-id>

pnpm build
pnpm --filter @easyclaw/desktop dist:win
# Output: apps/desktop/release/EasyClaw Setup <version>.exe

Cross-compiling from macOS works (NSIS doesn't need Wine). For code signing on Windows, set:

CSC_LINK=<path-to-.pfx-certificate>
CSC_KEY_PASSWORD=<certificate-password>

The scripts/release-local.sh script handles the full pipeline:

./scripts/release-local.sh 1.2.8            # full pipeline
./scripts/release-local.sh --skip-tests      # build + upload only
./scripts/release-local.sh --skip-upload     # build + test, no upload

This will:

1. Prebuild native modules for Node.js + Electron
2. Build all workspace packages
3. Run unit tests and E2E tests (dev + prod)
4. Build macOS DMG/ZIP or Windows NSIS installer
5. Upload artifacts to a draft GitHub Release

desktop dev auto-rebuilds better-sqlite3 for Electron's Node ABI. This means tests may fail afterwards with a NODE_MODULE_VERSION mismatch. Fix with:

pnpm install   # restores the system-Node prebuilt binary

Tests use Vitest. Run all tests:

pnpm test

Run tests for a specific package:

pnpm --filter @easyclaw/storage test
pnpm --filter @easyclaw/gateway test

• Linting: oxlint (Rust-based, fast)
• Formatting: oxfmt (Rust-based, fast)
• TypeScript: Strict mode, ES2023 target, NodeNext module resolution

pnpm lint
pnpm format       # Check
pnpm format:fix   # Auto-fix

The website/ directory contains the static product site hosted at www.easy-claw.com:

website/
├── site/           # Static HTML/CSS/JS (i18n: EN/ZH/JA)
│   ├── index.html
│   ├── style.css
│   ├── i18n.js
│   ├── update-manifest.json
│   └── releases/   # Installer binaries (gitignored)
├── nginx/          # nginx config (HTTPS, redirect, caching)
├── docker-compose.yml
└── init-letsencrypt.sh

On the production server:

cd website
./init-letsencrypt.sh   # First-time SSL setup
docker compose up -d    # Start nginx + certbot

See LICENSE for details.