Deepseek-Harness-EAC

EAC = Embracing All Creation（揽尽万象）

中文 | English

Download · Quick start · Architecture · Community

Turn agent capabilities into a desktop built for real work.

Deepseek Harness EAC is an open-source desktop workspace built on DeepSeek Harness. It brings conversations, project files, tool execution and extensions together, with native windows, separate runtime environments and bundled dependencies to get you from installation to work.

EAC · Embracing All Creation. Open capabilities, clear boundaries: the shell owns the desktop experience, the service layer owns orchestration, Harness owns the agent, and extension packages open up new possibilities.

Contents

Capabilities

Model requests use your configured provider. Activation, compatibility and additional dependencies depend on the distribution package and extension configuration.

Quick start

Download and launch

EAC Launcher (standalone multi-instance / multi-kernel manager, installs alongside the desktop app): EAC-Launcher v0.1.0 for Windows x64 ships its own Node 24.22.1 runtime, so no separate Node install is needed. See launcher/README.md for usage.

Latest stable Windows release: v6.0.0. Other platforms link to the most recent published package for each listed format.

Release notes · SHA256SUMS.txt

Update times are GitHub asset update timestamps. Platform packages may belong to different release generations; consult their release notes before installation. Windows uses WebView2; cloud models require network access and provider credentials.

1. Launch the application and wait for the local dsh service and Web UI.
2. Configure your model, including provider and API key.
3. Select a workspace, describe a task, and let the agent work in project context.
4. Review the result through conversation output and file-change views.
5. Extend as needed with plugins suited to your workflow.

Compute the file hash in PowerShell and compare it with the checksum manifest from the same release:

Get-FileHash -LiteralPath '<downloaded-file-path>' -Algorithm SHA256

Architecture

One desktop entry point. Three distinct responsibilities. EAC separates operating-system integration, runtime orchestration and the agent kernel so that desktop experience and extensions can evolve independently.

From launch to execution

1. The shell locates resources and starts the sidecar, passing the product data root and channel.
2. DPX creates or reuses an environment, applying runtime variables before user configuration and plugin modules are read.
3. The service layer prepares the profile and companion plugins, launches dsh, and waits for readiness.
4. The main window opens the Web UI. Harness handles conversations and tool execution; desktop operations reach the host through the bridge.

Rust and Node communicate over stdio JSON-RPC, keeping protocol output separate from diagnostics. Environment initialization failures stop startup and report the error instead of continuing under the wrong data root.

Keep complexity within explicit boundaries

• Separate native integration from business services. Native capabilities belong in L1, orchestration in L2, and extensions connect through plugin contracts.
• Reuse established environment management. DPX owns registry state, identity and default paths; EAC calls it through an adapter instead of maintaining a second rule set.
• Make distribution explicit. Plugin directories, synchronization manifests and dependency artifacts define the package, exposing missing resources during staging.
• Pin interface resources. UI skin manager and default-shell artifacts are locked and checked with SHA-256 during assembly.

Read the decisions on layering, environment isolation, and core scope.

Plugins and appearance

Desktop companion capabilities

Companion plugins use Harness host/client contracts. The staging script assembles these modules:

Extension distribution

Plugins are classified as builtin / recommended / external. Assembly manifests define bundled capabilities; package metadata defines recommended collections and external extensions. Choose extensions for their functionality, and manage them by source, version constraints and license.

Explore the distribution specification, plugin ledger, and source records.

Skin contracts

User Web UI skins are installed through market packages; without an activated skin, the host uses its native appearance. The shell's UI skin manager and system.default resources are pinned by the artifact lock. Regions, slots and exposed capabilities are defined in the host profile.

Skins own presentation; the host owns capabilities and window boundaries. Explicit contracts reduce coupling between visual customization and business logic.

Data and environments

EAC organizes desktop data in separate DPX environments, using the web-desktop profile. Environments are named eac-<channel>: the same channel reuses its environment, while different channels have separate storage.

<product-data-root>/
└── dpx/dsh-environments/eac-<channel>/
    ├── .dpx-environment.json      # environment identity
    ├── dsh-home/                 # profiles, sessions, skills and configuration
    ├── home/                     # environment user directory
    ├── appdata/                  # application data
    ├── localappdata/             # local application data
    ├── tmp/                      # temporary files
    └── workspace/                # environment workspace

Windows defaults to %LOCALAPPDATA%\Deepseek Harness EAC; other platforms derive their system data directory. Host ~/.dsh is detected and reported, not automatically migrated, deleted or overwritten.

Quit the application before backing up the actual product data root and separate project directories. Portable describes the application distribution format; environment configuration determines where data lives.

DPX redirects default paths and environment variables; it does not provide filesystem sandboxing. Operating-system permissions still govern access to explicit absolute paths. See environment.ts.

Development

Repository map

tauri-shell/       Rust shell, sidecar, bridge, resource staging and packaging
dsh-desktop/       TypeScript services, companion plugins, build scripts and tests
third_party/       External dependencies pinned to commits
.sync/             Plugin source, distribution and synchronization ledgers
docs/adr/          Architecture decisions and module boundaries

The packaging matrix covers Windows/Linux x64 and arm64; the repository also includes macOS platform configuration. Get binaries from Releases and consult the installer workflow for source builds.

Use Git, Node.js 24, pnpm 11.7.0 and Rust stable. Windows needs C++ build tools for the Rust target; Linux needs Tauri/WebKitGTK dependencies.

git clone --recurse-submodules https://github.com/says693/Deepseek-Harness-EAC.git
cd Deepseek-Harness-EAC
git submodule update --init --recursive
node tauri-shell/check-dpx-pin.mjs
npm install --global pnpm@11.7.0

cd dsh-desktop
node scripts/fetch-kernel.js
npm run ci:install
npm run typecheck
npm run build
npm run fetch-runtime
npm test
cd ..

Kernel dependencies use local vendor/kernel artifacts. Fetch the pinned kernel before installing dependencies. Building downloads dependencies from the network.

For Windows, from the repository root:

node tauri-shell/stage-resources.mjs --target=win32 --skip-npm
node dsh-desktop/scripts/verify-staged-runtime.mjs
cd tauri-shell
cargo fetch --locked
npx -y @tauri-apps/cli@2 build --verbose

For Linux, use --target=linux and set APPIMAGE_EXTRACT_AND_RUN=1 during the build. Ubuntu build dependencies:

sudo apt-get update
sudo apt-get install -y libwebkit2gtk-4.1-dev libappindicator3-dev librsvg2-dev patchelf libfuse2 rpm

For portable archives, see make-portable.mjs.

Run type checks, tests and ledger checks from dsh-desktop:

npm run typecheck
npm test
node scripts/plugin-ledger.mjs
node scripts/plugin-sync.mjs validate

Startup, bridge, environment and packaging changes also require relevant runtime validation. Choose checks using the development guide and follow CONTRIBUTING.md.

Documentation and community

• Architecture decisions: layering, isolation, skins and plugin distribution.
• Issues: reproducible bugs, feature proposals and feedback.
• Contribute: code, extension compatibility, platform support and documentation.
• Contributors: the people building EAC.
• Ecosystem credits: plugin authors, skin sources and license records.

Include the application version, operating system, package format, reproduction steps and redacted logs in bug reports to help trace environment and runtime behavior.

Community and support

Discuss workflows, plugins and troubleshooting with the community.

Contributors and acknowledgements

Thank you to the developers who contribute code, platform support, plugins and documentation to EAC.

Ebony-Vinyl · metaone01 · jing-hy · zixin947 · says693 · dtyg123 · lanyun077 · BAIKAI23333 · nishantpurohit04 · ViscaOwO · jiang8297 · Luoye-hb · look-back-lysj · T-Auto · maliang233 · lbn2011

Special thanks to @Nuomi9 for the macOS port (PR #234). Plugin and skin authors are recorded in ecosystem credits.

License and acknowledgements

EAC uses the MIT License. Thanks to DeepSeek Harness, dsh-dpx, Tauri, and every plugin, skin, platform and documentation contributor.

Third-party components retain their own copyrights and licenses. Skin sources include CC BY-NC-SA 4.0 material; usage and redistribution must follow the relevant component terms.

Star history