dsh-plugin-manager

English | 简体中文

dsh-plugin-manager is a DeepSeek Harness (DSH) extension manager. It organizes DSH plugins, Skills, and MCP servers into named configuration sets, then compiles the selected set into the runtime objects required by DSH. It is installed into an existing DSH profile, not run as a standalone application.

The manager is designed for explicit, reviewable changes:

• Package installation and catalog registration are explicit operations.
• A catalog entry does not install a package by itself.
• A configuration set is not active until it is applied.
• load, skip, and inherited states are visible for every managed extension.
• Secrets are represented by environment-variable references instead of being stored in the catalog.

Compatibility

The current plugin release targets DeepSeek Harness 0.1.1-rc.2 and the 0.1.1 release line. Its DSH client and settings peer dependencies are declared as ^0.1.1-rc.2, so the package manager can reject an older profile instead of silently loading the manager against an incompatible API.

DSH version	Status	Notes
0.1.1-rc.2	Supported	Current development and verification baseline.
0.1.1	Peer-compatible	The stable release is accepted by the declared peer range.
0.1.0-rc.7 and earlier	Not a target	This plugin release is no longer declared against the previous DSH line.

Compatibility covers the DSH client connection, runtime, UI slots/layout, settings, and plugin-settings APIs used by this extension. It does not modify the DSH source checkout. For a different DSH release line, verify the plugin with that profile before using it in production and update the plugin's peer range only after the corresponding APIs have been checked.

Installation

Requirements

• DeepSeek Harness 0.1.1-rc.2 or a compatible 0.1.1 profile.
• Node.js ^22.19.0 or >=24.0.0.
• A DSH profile, normally web, that can load the manager's peer packages.

The manager does not modify the DSH source checkout. It installs into the selected profile and contributes its own bundle and client entry points.

Install from a checkout

git clone https://github.com/DaoCaoRenH/dsh-plugin-manager.git
cd dsh-plugin-manager
pnpm install
pnpm build
dsh plugin --profile web add .

Replace web with the profile you use. When running DSH from its source checkout, use pnpm dsh plugin --profile web add . from the DSH repository. Restart DSH after installation, then open Extension Manager from the sidebar.

Install a published package

From an existing DSH installation, replace the local path with the published package specifier:

dsh plugin --profile web add dsh-plugin-manager

The profile installer adds the bundle to the profile manifest. The manager is loaded the next time that profile starts.

Features

Plugin management

• Snapshot the plugins already present in the selected DSH profile.
• Add managed plugin definitions with a module specifier, capabilities, placement, categories, configuration, and exposed MCP tools.
• Distinguish configured state from the live Loader runtime state.
• Keep stable installation identity for npm and GitHub packages.
• Protect DSH infrastructure and manager dependencies from accidental removal.
• Search, filter, sort, inspect, enable, skip, and remove plugins from the configuration workspace.
• Install a package through DSH and register it only after the installation succeeds.

Configuration sets

• Create named sets such as default, research, or minimal.
• Inherit from an existing set.
• Override each plugin or MCP server with load or skip.
• Apply the selected set to generate a managed Agent Preset and Host composition.
• Keep the selected set, the currently active set, and unsaved changes visibly separate.
• Apply a new set without editing DSH source code.

Skill management

• Read Skills from the official DSH Skill registry and show provider/source information.
• Import a Skill from a local directory or a GitHub repository, tree, or SKILL.md URL.
• Save and display the installed Skill path and provenance.
• Pin GitHub imports to a resolved commit before copying them.
• Edit supported invocation frontmatter without reformatting the rest of the SKILL.md document.
• Add notes, search notes, set load/skip, and move managed Skills to a recoverable manager-owned trash area.
• Keep bundled, runtime-owned, unknown, and out-of-root Skills read-only.

MCP management

• Manage MCP servers through the same catalog and configuration-set model as other extensions.
• Support stdio and streamable-http transports.
• Add one server manually with precise command, arguments, environment references, URL, headers, timeout, reconnect, and startup-error settings.
• Paste MCP JSON containing one or more servers and preview each server before saving.
• Detect an HTTP URL or a stdio command in the quick-add flow.
• Convert pasted secret values to envRef references instead of persisting plaintext secrets.
• Show runtime diagnostics, exposed-tool matches, startup failures, and configuration-set state.

Markets

The workspace exposes three separate market pages:

Market	Source	Installation target
Plugin market	awesome-dsh-plugin.com and the GitHub dsh-plugin topic	DSH plugin package
Skill market	SkillsMP	A local Skill directory
MCP market	Official MCP Registry	A managed MCP server definition

Each market supports the functions that apply to its source:

• Search across the loaded market snapshot instead of only the visible page.
• Filter by category, source, registration/installation state, or status.
• Sort plugin results by directory order, recently added, or stars.
• Paginate the displayed results.
• Open source and installation details before taking action.
• Preview the resulting files or configuration before confirmation.
• Refresh explicitly when new source data is needed.
• Reuse the previously loaded snapshot when switching between workspace panels, avoiding repeated large requests.

The first market load targets 1,000 entries. The target can be changed in the market page to load more or fewer entries in one operation. Loading stops when the source has no more results and reports that the source returned its limit; the source's own limit remains authoritative.

How it works

The manager has two runtime ownership planes:

DSH capability	Generated runtime object	Purpose
tool, context	pm-<set-id> Agent Preset	Agent-facing tools and context
mcp, host, ui	Managed Host composition	Host-level plugins and MCP connections

The workflow is:

1. The manager reads or creates catalog.yaml.
2. A configuration set resolves its parent chain and applies local load/skip overrides.
3. The resolved plugin set is validated.
4. tool and context entries are compiled into the generated Agent Preset.
5. mcp, host, and ui entries are compiled into the Host composition.
6. Applying the set updates DSH's active runtime state.

The manager keeps catalog state separate from live Loader state. A package can be installed but skipped by the active set, or present in the catalog but unavailable in the selected profile. The UI and dsh-pm validate expose that difference instead of treating the two states as the same.

The manager also preserves the initial DSH plugin baseline when it bootstraps its catalog. Later configuration changes are explicit and do not rewrite DSH source files.

Quick start with the CLI

Initialize the manager's catalog:

dsh-pm init

Add a plugin definition and load it in the default set:

dsh-pm plugin add pwsh --module @deepseek-ai/dsh-tool-pwsh --capabilities tool --categories shell
dsh-pm plugin add-to-set pwsh default
dsh-pm validate
dsh-pm apply default

Create a set that inherits from default, then override one plugin:

dsh-pm set add research --description "Research tools" --extends default
dsh-pm plugin set-state pwsh research skip
dsh-pm set resolve research
dsh-pm apply research

Add an MCP server definition. The command below writes configuration to the catalog; it does not install an npm package:

dsh-pm plugin add memory --module @deepseek-ai/dsh-mcp-client --capabilities mcp --config '{"transport":"stdio","serverName":"memory","command":"npx","args":["-y","@modelcontextprotocol/server-memory"],"env":{},"cwd":"","toolCallTimeoutMs":60000,"failOnStartupError":false}'
dsh-pm plugin add-to-set memory default
dsh-pm validate
dsh-pm apply default

After applying a set, start a new DSH session with the generated pm-<set-id> Agent Preset. Host-level MCP changes are applied as part of the managed Host composition.

Useful inspection commands:

dsh-pm list
dsh-pm list --json
dsh-pm set resolve default --json
dsh-pm validate

Global CLI options:

--home <path>       DSH home directory
--profile <name>    DSH profile used for module resolution
--dsh-root <path>   DSH source or installation root used by the installer
--catalog <path>    Override the catalog.yaml location

Extension Manager workspace

Open Extension Manager from the DSH sidebar. The Settings entry provides the status summary and entry point; the full workspace contains separate pages for the actual operations.

Management pages

• Configuration sets: create, remove, describe, inherit, resolve, and apply sets.
• Plugins: inspect installed/runtime plugins, edit catalog metadata, and change their state in the selected set.
• Skill: inspect discovered Skills, import local or GitHub Skills, edit supported metadata, manage notes, and choose load or skip.
• MCP: add, inspect, diagnose, edit, remove, and enable/skip MCP servers.

Market pages

• Plugin market: preview and install a plugin package, then add its verified definition to the selected set.
• Skill market: preview a GitHub Skill source, select its target root and state, then copy it and save its provenance after confirmation.
• MCP market: preview the normalized server configuration, review environment references and transport, then save it to the selected set.

Installation semantics

The explicit actions have different effects:

Action	Effect
Manual plugin add	Parses one DSH install command and writes a catalog definition; it does not execute installation.
Plugin market Install and add	Runs the DSH plugin installation flow first, then registers the verified plugin only after success.
Skill import	Resolves and copies a local or pinned GitHub Skill after preview confirmation, then saves path and provenance.
MCP quick add/manual configuration	Validates and saves a managed MCP definition; the configured command is used when the Host composition starts.
Apply configuration set	Compiles the selected set and updates the DSH runtime objects.

Preview actions are side-effect free. Review the package specifier, target path, server name, transport, command, arguments, environment references, and configuration-set state before confirming.

Data locations

The manager stores durable configuration under the DSH home directory:

~/.dsh/plugin-manager/catalog.yaml
~/.dsh/plugin-manager/state.yaml
~/.dsh/plugin-manager/host.cordis.yml
~/.dsh/plugin-manager/skill-notes/
~/.dsh/plugin-manager/mcp-notes/
~/.dsh/.agent-presets/pm-<set-id>/agent.cordis.yml

catalog.yaml is the source of truth for plugin definitions, categories, and configuration sets. state.yaml records the active set. The generated Host composition and Agent Presets are derived runtime artifacts and can be regenerated by applying a set.

Do not commit a user's DSH home directory, catalog, notes, generated presets, or credentials to a public repository.

Safety and compatibility boundaries

• Only supported DSH plugin package specifiers are accepted by the installer; arbitrary shell text is not executed.
• Plugin installation uses the DSH CLI for the selected profile.
• GitHub Skill imports validate the repository reference, resolve a commit, and do not execute repository scripts.
• MCP commands run as trusted Host processes. Review commands, arguments, working directories, and environment references before applying them.
• Secret values are not stored in the catalog; use envRef and configure the corresponding environment variables in the runtime environment.
• The manager does not automatically upgrade or uninstall packages.
• Removing a catalog entry does not remove a package from the DSH profile.
• Only one configuration set is active process-wide. Agent Presets are generated per set, while Host-level MCP connections are process-level.

Development

Install dependencies, type-check, test, and build:

pnpm install
pnpm check
pnpm test
pnpm build

The package is published under the MIT license. See LICENSE.