Dev Manager — a DSH plugin

A right-Sidebar plugin for DeepSeek Harness (DSH) that detects how a project is built and runs its commands with live logs and stop buttons.

Features

• Package-manager detection from packageManager and lockfiles: npm, pnpm, yarn, bun.
• Polyglot commands from the project manifests: Composer (PHP, including artisan), Cargo (Rust), Go modules, Python (uv/poetry/pipenv/pip, Django manage.py), Bundler/Rake (Ruby), Maven/Gradle (Java), .NET, Makefile targets, and Docker Compose.
• Run buttons for every detected command — dev servers, builds, tests, linters, dependency installs.
• Custom scripts per project: add your own shell command line (a seeder, a generator, anything), run it, and delete it later. Custom commands and groups are stored per project directory under the harness home (~/.dsh/dev-manager/projects.json, override with DSH_DEV_MANAGER_STORE), never inside the repository.
• Script groups per project: bundle several detected scripts and/or custom scripts into a named group and start them all with one Run all click. Groups are scoped to their project by default; other projects never see them.
• Live logs in the tab: stdout/stderr stream every ~0.5 s, follow the tail automatically, pause when you scroll up, and flag lost output when the retained window rolls over.
• Stop buttons for long-running commands (npm run dev, cargo run, docker compose up, …): the Host sends SIGTERM to the process group and settles the record as stopped.
• Process list per Session with status, elapsed time, and retained logs; running commands survive tab close and page reload and can be stopped later.
• Theme-aware and localized UI (English and Simplified Chinese) with collapsible sections, language-colored ecosystem tags (Node green, PHP purple, Rust orange, Go cyan, …), manager-colored badges, and subtle colored action buttons built from the Host's design tokens.
• Original artwork, display metadata, and locale resources for the Plugin Manager.

Install

This repository is a DSH bundle: a Host half (index.js) plus a Web client module (client.js).

1. Clone this repository somewhere stable.
2. Install it into a DSH profile from a DSH agent session with the Plugin Manager's install_bundle action, using this directory as the target. The tool links the directory into the profile, adds the bundle to the profile's bundle list, and activates it live.
3. Open the Web UI, open the right Sidebar, and click the Dev card.

The plugin row lives in cordis.patch.yml; display metadata is exported from locale/*.json and icon.svg.

Usage

• The tab is bound to the current Session's project directory, so each Session manages its own project.
• Run starts a command and keeps the project view open (the command appears under Processes, and the row switches to Logs).
• Custom scripts → + adds a name and a shell command line to the current project.
• Groups → + creates a group; expand it to rename it, add or remove member scripts, or delete it, then Run all starts every member at once.
• Stop terminates a running command; Dismiss removes a settled record (and its logs).
• Refresh re-scans the project when manifests change.
• Commands, Custom scripts, and Groups are collapsible; the collapse choice is remembered in the browser. Processes always stays open so running work is never hidden.
• Logs on an action row or process row reopens retained output; scroll up to stop following and use Jump to latest to resume.

Supported ecosystems

Ecosystem	Detection	Example commands
Node.js	package.json, packageManager, lockfiles	npm run dev, pnpm run build, yarn run test, bun run dev
PHP	composer.json, artisan	composer run-script test, php artisan serve
Rust	Cargo.toml	cargo test, cargo run, cargo clippy
Go	go.mod	go build ./..., go test ./...
Python	pyproject.toml/requirements.txt/Pipfile, manage.py	uv run pytest, poetry install, python manage.py runserver
Ruby	Gemfile, Rakefile	bundle install, bundle exec rake test
Java	pom.xml/build.gradle* (with wrappers)	./mvnw test, ./gradlew build
.NET	*.csproj/*.sln	dotnet build, dotnet test
Makefile	Makefile targets	make dev, make test
Docker	compose.yaml/docker-compose.yml	docker compose up, docker compose down

Lifecycle hooks (Composer pre-*/post-*, npm predev/postbuild) are hidden because their owning commands run them implicitly.

How it works

• Host half (index.js) resolves the Session's working directory, inspects manifests through ctx.fs, resolves executables, and starts commands through ctx.subprocess with offset-based collected output. It serves a small JSON API on the authenticated DSH /api channel:
  • GET /api/dev-manager/state?sessionId=…[&refresh=1]
  • POST /api/dev-manager/run { sessionId, actionId }
  • POST /api/dev-manager/stop { processId }
  • GET /api/dev-manager/logs?processId=…&stdoutFrom=…&stderrFrom=…
  • POST /api/dev-manager/dismiss { processId }
  • POST /api/dev-manager/config { sessionId, op, …fields } (custom-script and group operations)
  • POST /api/dev-manager/run-group { sessionId, groupId }
• Client half (client.js) registers a right-Sidebar tab type with a guide entry, renders the tab, and polls the Host API for state and log deltas. It uses the Host's theme tokens and locale service; no Host client packages are imported.
• Pure detection, process-registry, and per-project configuration logic live in lib/detect.js, lib/manager.js, and lib/config.js, and are unit-tested.

Development

npm test   # node --test tests/*.test.mjs

The tests cover detection across all ecosystems, process lifecycle (run/read/stop/dismiss/shutdown), per-project custom scripts and groups, the Host HTTP route layer with a stand-in context, and the client module's registration contract and locale resources.

Known limits

• Logs keep a bounded tail (256 KiB per stream on the Host, 400k characters in the tab); truncation is reported in the UI. stdout/stderr are merged per poll, so their relative order is approximate.
• Custom scripts and groups are keyed by the absolute project path, live in the harness home, and are not shared through the repository (the config file location can be pointed elsewhere with DSH_DEV_MANAGER_STORE).
• Commands are children of the DSH Host process: closing the tab or Session does not stop them, but a Host restart does. Use the Stop button.
• A custom script runs through the platform shell ($SHELL//bin/sh on POSIX, cmd.exe on Windows), so pipes and && work; it inherits the project directory as its working directory.
• Groups intentionally do not stop their members: a running group keeps its member processes independent until you stop them individually.
• Changing the Host half requires a DSH restart; the client half reloads live through the Web HMR transport during development.