DSH Plugins Marketplace

DSH Plugins

Plugins

/

dsh-supervision

b

dsh-supervision

Manifest valid★ 4

Bridge a running DSH session into any terminal supervisor — it sees the state, and it can steer.

UI (client)hasBundlePatch

preview

dsh-supervision

English | 中文

npm license node DSH

Bridge a running DSH session into any terminal supervisor — it sees the state, and it can steer. The plugin mounts inside the dsh web process you already run: OSC 7501 records go out on the terminal, and operator input comes back into that same session. herdr-core is one supported supervisor; any supervisor that reads OSC 7501 and can write lines back can drive a bridged session, with no changes to DSH or the supervisor.

What you get

  • One status record per session. The bridged session is the root record — idle, working, done, blocked or error; other sessions in the same process are child records carrying id=.
  • Operator input goes back in. Bare text steers a running turn, /cancel ends it, /status, /new and /attach inspect and switch sessions, and /approve or /reject settle parked asks — all from the terminal.
  • Approvals stop living in another surface. A parked ask turns the root record into blocked · kind=permission, is settled from the terminal, and the GUI shows it at a glance — ringed sidebar row, covered input area — and one Unlock button takes the session back — so the person in the browser always sees who holds the session and has a way to take it back.

Works with

SupervisorHow it connectsWhat it needs
herdr-core (hc)in-process tty via its own HC_TERMINAL_ID (or DSH_SUP_TERMINAL_ID when the host exports one) and the control socket with dsh-sup in its PTY; both are open at oncea dsh web started inside the supervised terminal, plus any PTY for the forwarder
Any supervisor that reads OSC 7501control socket + dsh-sup in its own PTYit must read the PTY's OSC output and be able to write lines to that PTY's stdin
Another supervisor wanting in-process modeset DSH_SUP_TERMINAL_IDthe variable is read, never written, by this package; any supervisor can set it
GUI-only dsh webnothingthe plugin exposes an inert socket and nothing else

Quick start

Install

Plugins page — in DeepSeek Harness open the Plugins page, click Add plugin, enter dsh-supervision and install; then restart as the host asks. The GUI writes into the web profile, the same profile the command below targets.

CLI — for scripted setups:

dsh plugin --profile web add dsh-supervision   # the plugin, into the web profile
npm i -g dsh-sup                               # the forwarder, for the supervisor's PTY

dsh-sup is a separate package because it runs as its own program in the supervisor's PTY. Pin a version with @<version>.

Supervisor-side agent

Give this to the agent that drives the supervisor's terminal: it sets up the matching forwarder, reads the manual, and keeps what it learned for later sessions:

Read the installed plugin's version: `dsh plugin --profile web list` prints `dsh-supervision@<version>`, and for a `link:` row read `version` from that path's `package.json`. If the `dsh` command is missing or the list shows no `dsh-supervision` (a desktop DSH has no CLI), ask me whether to install the forwarder, and on my yes run `npm i -g dsh-sup@latest` — latest, without asking about a version again. Otherwise run `dsh-sup --version`: if the command is missing or prints anything other than that exact string, say what you found and, only after I agree, install it with `npm i -g dsh-sup@<plugin-version>`. Then run `dsh-sup --skill` and treat that printed manual as the authority: record how to use the forwarder — the version coupling, install and upgrade, and the session operations in the manual's own terms — in the skill, memory or AGENTS.md you use for supervisor work. Do not create or attach a session now; this is only about knowing how to use it before the work starts.

Connect a session

dsh-sup                                  # create a session in the dsh-sup process's directory
dsh-sup --cwd ~/work/project             # create it elsewhere (resolved here, then sent absolute)
dsh-sup attach session-abc123            # attach an existing session (or: dsh-sup session-abc123)
dsh-sup --pid 4711 new                   # pick the backend when several dsh web processes run
dsh-sup list                             # list every session on every live backend

list prints one table for every live backend and binds nothing. It answers from the same account the sidebar groups — the sessions a Workspace owns — so a persisted session appears even when no agent is loaded for it (LIVE no), while archived sessions and sessions no Workspace owns (subagent logs, folded history) are omitted. Blank sessions (never had a turn) are omitted too: the sidebar shows one only while it is the selected session, so listing it would name an id with no row to open — send one line and it appears in both places. An archived session is the single exception: an active bridge holds it, so it stays listed. PID names the dsh web process a row came from, so a multi-backend listing stays attributable:

SESSION            PID    CWD                LIVE  BRIDGED
session-4f2a…      4711   /Users/me/work     yes   -

Backends are found through $DSH_HOME/supervision (~/.dsh/supervision when DSH_HOME is unset). A bridge needs exactly one live backend; with several, the refusal names each candidate's pid and socket, and --pid picks one. --cwd applies to new and list only; list without it shows every session, with the CWD column naming where each one lives.

With --no-tui, or when stdin or stdout is not a terminal, the bridge reads stdin in the terminal's own line mode — it never enters raw mode — so Ctrl+C, Ctrl+Z, Ctrl+\, input echo and line editing keep working as they do without the plugin. Ctrl+S/Ctrl+Q stay the terminal driver's flow control: on the /dev/tty surface a paused terminal holds the bridge's records in an ordered queue instead of blocking the host, and they flush on resume. The stdout fallback (no controlling terminal) keeps a synchronous write, so there a paused terminal still stalls it. Operator input is read a line at a time, after Enter; the line discipline caps one line at its MAX_CANON (4 KB on Linux, 1 KB on macOS), so a much longer paste reaches the agent truncated. In a terminal, an attach opens the full-screen attach surface; a redirected stdout stays machine-clean (see How it reports).

Empty sessions stay out of the web UI. A session created here is attached to its project, but the DSH sidebar lists a session only after its first message. Until then it exists in dsh-sup list and on the bridge, with no row under the project. Send one line from the terminal (or attach and steer) and it appears.

Attach surface

When stdin and stdout are both terminals, an attach opens a full-screen surface instead of appending lines: the conversation in a scrollable transcript viewport, a multi-line editor for the next operator line, and a status line carrying the session id, the reported state and the turn. The turn is shown only while the plugin's echo config is on: nothing after welcome carries a count when echo is off, so the bar keeps the state live from OSC records (while programStatus is on) and shows no turn rather than freezing one. With programStatus off those records stop arriving, so the state stays at the value the attach reported — frozen, still shown. Everything the bridge forwards stays in the transcript, so scrolling back reaches the whole attach. The surface takes over the terminal's alternate screen while attached: terminal scrollback is not written, the TUI viewport is the history, and the last frame is printed back on the normal screen when the attach ends.

KeyEffect
Entersend the editor's text as one operator line
Shift+Enterstart a new line in the editor, when the terminal reports the modifier (modifyOtherKeys or the Kitty keyboard protocol); otherwise it submits like Enter
Ctrl+Cclear what you typed; on an empty editor it hints, and a second press within 1.5 s leaves the attach (any other key resets that window)
Escclose the completion menu if one is open; otherwise send /cancel, which ends the running turn and keeps the attach
Ctrl+Dleave the attach; the terminal is restored first
PageUp / PageDownscroll the transcript one page
↑ / ↓scroll one line, while the editor is empty
Home / Endoldest line / back to the newest (when the editor is empty)

Scrolled back, the last row shows ↓ N new for the entries that arrived meanwhile, and scrolling to the bottom resumes following the live transcript. The surface is drawn with @earendil-works/pi-tui.

The surface is themed, so input and output are distinguishable at a glance: the operator's line is a tinted block behind a ❯ gutter, assistant prose renders as Markdown (headings, lists, inline code, fenced blocks with a border), tool calls are coloured status rows (⏳ pending, ✔ ok, ✘ failed) with a dim detail line, system and echo lines are dim, the status bar is a reverse-video row with a colour-coded state, and the editor is framed in the accent colour. NO_COLOR, a non-terminal stdout, or TERM=dumb keeps the same layout with no colour, so captured output stays clean. Themes change how those lines look, never the keys in the table above or the bytes a redirected stdout receives.

--no-tui keeps the append-only line surface on a terminal; a redirected stdout always gets that line surface, so dsh-sup … | tee log stays machine-clean.

Untested platforms. Windows terminals (ConPTY) and tmux are unverified: no run has exercised the full-screen surface there. When you do, check three things first — the alternate screen is restored on every exit path (Ctrl+D, /q, a lost backend), the terminal reports a keyboard protocol the surface understands (modifyOtherKeys or the Kitty protocol, which decide Shift+Enter), and the pane has a /dev/tty the bridge can open; without one only the socket surface mounts, and the reason lands on stderr.

Suggestions. The plugin sends a catalog frame with the session's skills and registered host commands once the attach is up, and the editor turns it into a menu: typing / lists every entry, typing /skill: narrows to the session's skills as /skill:<name> (fuzzy-matching the bare name works too); Tab inserts the highlighted completion, while Enter accepts and sends it immediately. Skills come first, then the host commands the bridge can execute, then the forwarder's own exits. Local verbs win: a host row whose name the plugin resolves locally — /cancel, /status, /new, /attach, /approve, /reject, /answer, bare /skill, /y, /n and the exits — is not offered, and typing that name runs the local meaning. The one exception is a bare /skill: it is reserved for the skill menu and answered with unknown command /skill. A host command such as /compact executes in-process against the attached session and answers as one echo — its own result text, or /<name>: ok when it reports none. A multi-line result keeps its line breaks: each line the command writes arrives as its own terminal line. It sends no model message; the session log still records command/run and command/done, which the web view can show. The catalog frame is surface input only — it never reaches stdout or /dev/tty, and line mode ignores it. @file completion resolves against the session's directory when the fd binary is installed. /skill:<name> is rewritten to /<name> (plus any words after it) and steered as one user message; the host then injects the rendered skill body exactly as it does for the web composer. An unknown or non-user-invocable name answers skill not found: <name>. Known limits: the bridge carries no attachments, and the command lifecycle (command/run/command/done) is not mirrored into the terminal — the echo line is the whole report.

Leaving. /q, /quit, /exit and /bye — on a line of their own, lowercase, nothing after them — leave the attach from either surface (TUI or --no-tui): the forwarder sends bye, restores the terminal and exits 0. They are never forwarded to the session, so nothing is left waiting on the model. The forwarder also puts them at the end of the / menu as leave dsh-sup (local), so the way out never depends on what the host's catalog advertises. In the TUI, Ctrl+D still leaves outright, Esc closes an open completion menu first and otherwise cancels the running turn, and Ctrl+C clears the editor; on an empty editor it shows Ctrl+C again to exit and a second press within 1.5 s leaves. /q now or /quiet are ordinary input; trailing spaces are ignored, so accepting the menu entry and pressing Enter still leaves.

Answer an approval

Ask where the session stands, then answer the parked ask by id:

/status
session=session-4f2a… state=blocked turn=3 asks=3f9ac1

/approve 3f9ac1
[ask 3f9ac1] bash → allowed-once (source=supervisor)

/y and /n answer the only parked ask; with more than one parked they refuse and ask you to name it.

Answer an agent question

An ask_user_question call reaches the supervisor too: its card arrives in the transcript with every option numbered, and the root reports blocked:kind=question with msg=question: … [ask <id> /answer <id> N]. Answer every question of the ask by its id:

/answer 3f9ac1 db=2 why=because
[ask 3f9ac1] question -> answered (source=supervisor)

One token per question: q1=2 picks option 2, q1=1,3 selects both, q1=- skips it, and any other value is free text — the words after the first token join it, so q1=two words is one custom answer. With a single question the id may be omitted and the rest of the line is the value (/answer 3f9ac1 我的 想法). The full-screen surface prints the same card and, while exactly one ask is open, rewrites a bare 2 (or -, or 1,3) to /answer <id> 2; a multi-question ask then answers with the plugin's answer-grammar error line instead of steering the agent, and anything else is still an ordinary steer. From a herdr-core HUD the same line needs no attach: hc send <terminal> "/answer <id> 2". An asker that withdraws, or a bridge that goes away, skips every question and closes the card.

Take back control

While a session is bridged the GUI marks it in the sidebar and over the input area. The session's sidebar row wears a 3px blue ring on its own rounding, a light-blue translucent fill (rgba(127, 174, 255, 0.30)), and a wider blue capsule that fills the row height with an animated whale tail at its right edge, so a supervised session cannot be mistaken for one that is yours to type into. Opening it covers the whole input area — editor and toolbar — with a blue-bordered, light-blue translucent panel (rgba(127, 174, 255, 0.30)): the editor is made inert, so neither the pointer nor an already-focused caret can type into it. A blue caption tab sits on the panel's top edge, above the frame, quoting the shipped English string — "This chat is supervised from elsewhere — the input box is locked" (localized English/Chinese via the host locale service); a Bridged badge with a small white whale tail is fused into the overlay's bottom-left corner; and the panel's single Unlock button posts the reclaim — only a confirmed release removes the guard, so a refused unlock leaves it in place. On a host whose composer has no [data-composer-card] wrapper, only the editor is made inert; the toolbar stays operable rather than freezing the surrounding page container. The bridge is dropped, the supervisor reports the clear record, and a dsh-sup forwarder exits 0.

Agent skill

The plugin ships a use-dsh-supervision skill, so the agent inside a supervised session knows it needs the same-version dsh-sup forwarder, checks it with dsh-sup --version, and offers the install only after the user agrees. dsh-sup --skill prints the forwarder's full manual.

How it reports

One dsh web process owns one session tree; the plugin mounts in it and opens its control socket, plus an in-process tty when the process runs inside a supervised terminal.

dsh web (the process you already run)
└── dsh-supervision plugin
      ├── control socket   $DSH_HOME/supervision/<pid>-<8hex>.sock   (0600)
      │     └── dsh-sup in the supervisor's PTY ── OSC 7501 + echo + mirror lines ──▶ supervisor (reads OSC 7501)
      └── in-process tty   (added when DSH_SUP_TERMINAL_ID or HC_TERMINAL_ID is set)
            └── OSC 7501 records and mirror lines written to this process's own /dev/tty

Activation. The plugin always opens its socket discovery surface — the listener, the 0600 socket and the <pid>-<8hex>.json registry entry that names it — so a forwarder has something to connect to. The effect layer (session listeners, OSC reports, echo lines, stdin handling) mounts per bridge, which is the same fact as "a forwarder is connected". A GUI-only dsh web therefore exposes an inert socket and nothing else. With DSH_SUP_TERMINAL_ID non-empty (or herdr-core's HC_TERMINAL_ID) the process also supervises the terminal it runs in: the same records go to its own /dev/tty, while the socket stays open for a dsh-sup elsewhere. A session still has exactly one bridge across both surfaces, so a second attach is refused as busy. If the terminal cannot be opened — no /dev/tty and a non-TTY stdout, or a stdin that is not a terminal — the plugin writes the reason to stderr and keeps the socket surface.

Transcript output. The bridge also forwards the conversation itself. A mirror frame carries one item — an operator message, an assistant reply (with a ⟦↑in ↓out⟧ usage line whenever the adapter reported token usage), or a tool call — and the forwarder renders it for a person: in line mode as append-only lines (no colour, no markdown, no spinner, no alternate screen, and no existing line rewritten), in a full-screen attach in the transcript viewport. An attach first replays the last 200 items of the session's persisted log as ordinary mirror frames, and an echo line says so when the replay was truncated (history: showing last 200 items) or the log could not be read. OSC 7501 records keep going to /dev/tty, so a real supervisor still reads the machine surface; the line surface goes to stdout, and only when stdout is a TTY, so dsh-sup … | tee log stays machine-clean, while the full-screen surface exists only when stdin and stdout are both terminals. echo lines reach exactly one place: stdout in line mode when the operator has a TTY, the transcript viewport in a full-screen attach, /dev/tty otherwise. Mirror blocks wrap to the terminal's own width, read per frame; a redirected stdout reports none, so the in-process mirror then falls back to the protocol default of 100 columns even when /dev/tty is a real surface.

❯ implement the mirror
· One assistant/message per step; no deltas to stream.
The mirror prints finished blocks, one line at a time.
⟦↑1,234 ↓340 R900⟧
⏳ bash: List the protocol package
✔ bash: List the protocol package ⟦12ms⟧
  └─ packages/protocol/src

For implementers & agents

This half is reference material for implementers and coding agents; if you only want to use the plugin, jump to Links.

Repo map

PathWhat lives there
src/the host plugin and the browser supervision decoration (src/client/)
packages/protocolthe OSC 7501 encoder and the NDJSON frame codec
packages/clithe dsh-sup forwarder
lib/build output
docs/figures and their captions
.agents/adr and .agents/knowledgedecisions and the architecture notes behind them
.changes/release fragments
locale/plugin-page strings

Supervision protocol

The facts a supervisor needs, all of them on this repository's wire:

Socket and registry. One Unix socket per dsh web process, mode 0600, at $DSH_HOME/supervision/<pid>-<8hex>.sock, next to a <pid>-<8hex>.json entry {proto, pid, socket, startedAt, dshVersion} written atomically and mode 0600. A session has exactly one bridge: a second connection claiming it is refused with error code busy and closed. Frames are NDJSON, PROTO is 4, one frame is at most 64 KiB; the forwarder splits its own stdin on \r, \n or \r\n and sends one line frame per input line.

DirectionFrames
forwarder → pluginhello (attach a session, new {cwd}, or bare), line {text}, list {cwd?}, bye
plugin → forwarderwelcome, osc {data}, echo {text}, mirror {item} (item.k is user, assistant or tool), sessions {items}, catalog {skills, commands} (the menu, claimed by the surface), ask {id, questions} (a pending agent question card, or ask {id, closed} when it retires), error {code, message}, bye {reason}

error.code is one of busy, unknown-session, create-failed, locked, protocol, internal.

OSC 7501 output. One record is replaced whole on every report, so every field is restated:

ESC ] 7501 ; state=<idle|working|done|blocked|error>[ :id=<child id>][ :kind=<permission|question|auth>][ :app=<word>][ :title=<base64>][ :msg=<base64>] ST

A clear is state=clear for the root, state=clear:id=<id> for one child record. kind is legal only on blocked; a parked approval is the root blocked:kind=permission record carrying msg=<tool> <reason> [ask <id>], and a parked agent question is blocked:kind=question carrying msg=question: <question> [ask <id> /answer <id> N]. The approval wins when both are parked for one session. Caps: sequence under 4096 bytes, title 192 bytes, msg 2048 bytes, id 128 bytes as /-joined segments of at most 32 bytes each (8 segments). The root word is blocked > working > done / error / idle, and a parked approval outranks a live turn. The root also stays working while a descendant subagent (origin = subagent, lineage reaching the bridged session) is running, or a background job the session owns is running or stopping — not only while its own turn is live — and msg then carries the count (2 subagents · 1 job). If that activity's identity (a family's status, label or membership) has not changed for 5 minutes, the root falls back to the turn word and msg reads activity stale: …, with one matching echo line; the fallback clears when the identity changes, not merely when an event arrives. It guards against a stalled child or job, so a job that runs longer than 5 minutes without a status change reads done until its identity changes. The reporting surface is /dev/tty on both paths (stdout when it is a TTY); that is what the supervisor reads, not the plugin's or the forwarder's stdout.

Routes, served only when the host mounts a webserver:

RouteAnswer
GET /dsh-supervision/state{"proto":1,"sessions":{"<session id>":{"bridged":true,"terminal":"…","pid":<n>,"since":<ms>,"asks":["<ask id>"]}}}; 405 for another method
POST /dsh-supervision/reclaimcontent-type: application/json, body {"session":"<id>"} under 4 KiB → 200 {"reclaimed":true}; 409 {"reclaimed":false} when no bridge held it; 415 for another content type, 400 for a bad body

Echo lines the supervisor reads, each written when its fact happens: [turn <n>] <state> on a state change, [ask <id>] <tool> parked (<session>), [ask <id>] <tool> → <outcome> (source=supervisor|attached), [ask <id>] question -> answered|skipped (source=supervisor|attached), the /status answer above, refused: <n> ask(s) parked, new failed: …, attach failed: …, a host command's result (its own text, /<name>: ok, or command failed: …; an answer over the frame cap is cut and ends with … (truncated)), unknown command /<verb>. One-off diagnostics take the same sink: history unavailable: …, history: showing last <n> items, new superseded: …, no approval pending, <n> asks pending; name one, no ask <id>, skill not found: <name>, skill service unavailable, skill failed: …, activity unavailable: … and activity recovered. An ask frame carries the question card itself; a closed one retires it. When subagent/job activity outlives its window, its activity stale: … line is written immediately before that publish's [turn <n>] <state> line.

Exit codes of dsh-sup: 0 clean bye, 1 backend lost, 2 usage or no live backend, 3 busy, 4 locked, 5 create-failed, 6 protocol (a frame this process refused, so the backend is alive).

Configuration

Six keys, all of them read by src/index.ts; an unknown shape is refused with a field-level issue instead of half-applying.

KeyDefaultWhat it does
enabledtrueMount anything at all. false is a hard off switch: no socket, no routes, no client decoration.
programStatustrueEmit OSC 7501 reports. Off leaves the socket answering list only.
echotrueMirror state changes and approval decisions as echo lines for the supervisor. Off also drops the turn from the attach surface's status bar, because the count only advances on those lines.
app"dsh"The program word every report restates.
titleFrom"cwd-basename"Where the root title comes from: cwd-basename, session-title, or none.
socketDir$DSH_HOME/supervisionRegistry and socket directory.

Environment variables it reads:

VariableRead byEffect
DSH_HOMEplugin and dsh-supRegistry directory base; defaults to ~/.dsh.
DSH_SUP_TERMINAL_IDpluginNon-empty ⇒ an additional in-process tty transport; the control socket and registry stay open.
DSH_SUP_TERMINAL_NAMEpluginThe supervisor label the state route reports; defaults to dsh-sup.
HC_TERMINAL_IDpluginherdr-core compatibility: the same transport, read only when DSH_SUP_TERMINAL_ID is unset or empty.
HC_TERMINAL_NAMEpluginherdr-core compatibility: the label, read only when DSH_SUP_TERMINAL_NAME is unset or empty.

Both DSH_SUP_* variables and their HC_* fallbacks are read, never written, by this package.

Invariants

A change must not break these:

  • One bridge per session. A second connection claiming a bridged session is refused with busy; the in-process path holds one binding per process, and /attach switches it rather than adding a second.
  • A record is replaced whole. Every report restates every field that still applies; a field left out is a field cleared.
  • A parked approval outranks a live turn. The root word order is blocked > working > done / error / idle, and a session switch (/new, /attach) is refused while an ask is parked.
  • Teardown settles every parked ask before the socket closes. Disconnect, dispose, reclaim or an asker's withdrawal resolves each ask as cancelled; fail closed, never leave one dangling.
  • The terminal variables are read only. The in-process transport and its label are chosen by the environment, never by configuration, and nothing writes those variables.
  • Caps are hard limits. The encoder drops a record it cannot express within its caps rather than truncating it, and a frame over 64 KiB is refused locally.

Links

DocContent
CHANGELOG.mdreleased changes

License

Released under the MIT License — the license field in package.json is authoritative.

Comments

Loading…

Similar plugins

dsh-session-bridge

by FuWenLianggit

Session-level multi-thread orchestration for DeepSeek Harness: create ordinary sessions, send queued or interrupt prompts to any session by id, and enumerate sessions. Installs globally, independent o

Tools & CapabilitiesManifest valid

★ 0

↓ 474/wk

MIT

TypeScript

Oct 26, 2026

dsh plugin --profile web add dsh-session-bridge

by EasyTZ

终端面板:在当前工作区敲命令、看实时输出,多标签页、Tab 补全、Ctrl+C 中断。Terminal panel for DeepSeek Harness: run commands with streaming output, tabs, completion.

Development & InfrastructureTerminal & ClientsManifest valid

★ 0

MIT

JavaScript

Sep 5, 2026

dsh plugin --profile web add @easytz/dsh-terminal-panel

by Wha1eChai

Same-runtime cross-Session discovery and communication for DeepSeek Harness

Sessions & MessagesManifest valid

★ 2

↓ 6/wk

MIT

TypeScript

Aug 14, 2026

dsh plugin --profile web add @wha1echai/dsh-cross-session

by Asaiuta

Aggregate and natively control multiple remote DeepSeek Harness (DSH) servers' sessions from one official Web UI — hub gateway + official-UI bridge. 多服务器 DSH 会话聚合与原生操控

Development & InfrastructureTerminal & ClientsManifest valid

★ 7

↓ 174/wk

MIT

JavaScript

Nov 3, 2026

dsh plugin --profile web add dsh-session-hub

by phoenixlucky

DeepSeek Harness plugin: a normalized session view that renders every turn, message and tool call in one consistent, copyable format.

Manifest valid

★ 0

MIT

JavaScript

Nov 3, 2026

dsh plugin --profile web add dsh-session-norms

by GooDAnDReaDY

Session management for the DeepSeek Harness sidebar: pin and label conversations, search their contents, jump by keyboard, read and export archived transcripts

UI & ExperienceTerminal & ClientsSessions & MessagesManifest valid

★ 1

↓ 275/wk

MIT

JavaScript

Oct 15, 2026

dsh plugin --profile web add @goodandready/dsh-session-control