DSH ⇄ JetBrains

Small packages that connect a local DeepSeek Harness (DSH) to a JetBrains IDE, so the IDE and the agent share one workspace instead of two islands.

Each one works on its own: the IDE plugin and the DSH bundle are the two halves of the same workflow, and the session-link plugin only lets a page be asked for a session by address. The DSH bundle carries both a Host half and a web-client half, so installing it covers the tool, the context line, and the clicks.

Package	Platform	What it does
jetbrains-companion/	IntelliJ Platform plugin (Java, no Gradle)	DSH Chat tool window embedding DSH's own web client, one DSH session per IDE window, live workspace publication, a loopback bridge so DSH can put a file in front of you, and a DSH Changes tool window that shows a published turn as a native side-by-side IntelliJ diff.
jetbrains-workspace/	DSH profile bundle (host half + web-client half, plain JavaScript)	Reads the IDE's workspace — including a module's multiple content roots from its .iml — into DSH as a tool, a runtime context line, and a registered workspace. Works with the companion running or from the IDE's own state files after it closed. Sends opened and clicked files to the IDE: the Host half replaces DSH's default desktop opener, and the client half redirects the Sidebar file viewer.
jetbrains-session-link/	DSH client plugin (plain JavaScript)	Lets #dsh-session=<id> — or a hash change on an open page — select that session without a reload. Optional: the chat panel falls back to the client's stored selection when it is absent.

Unofficial. Neither package is made by, endorsed by, or affiliated with JetBrains or DeepSeek. IntelliJ, IDEA and JetBrains are trademarks of JetBrains s.r.o.

What you get

• Chat inside the IDE. The DSH Chat tool window renders DSH's web client, authenticated with the same browser-session cookie DSH gives a browser, and opens the session for the window you are in.

• One workspace, seen from both sides. The window's root project and every attached module/VCS directory reach the model as a runtime context line and as a jetbrains_workspace tool result, with each directory labelled by the source that reported it.

• Round trip. DSH can read the active file, caret and selection, and open a file in the IDE at a line — with the companion's bridge, or with the IDE state files when the IDE is closed.

• Review a turn as a diff. DSH Changes lists every turn dsh-jetbrains-workspace publishes and opens any changed file as a native side-by-side IntelliJ diff. A turn's diff also opens by itself, with a Keep / Revert notification, the chat panel's toolbar has a Changes toggle, and reverting works per file or per hunk — refusing rather than half-reverting a file that changed since the turn.

• Nothing is lost while the IDE is closed. The review document outlives the IDE: on the next start the companion mentions the turns it missed, with one click to the panel.

Why one DSH, not one per project

Because the value is in seeing everything at once. One Host process holds every session, so a reader can keep an agent running in one project under watch while working on something else in another session that has nothing to do with the IDE. It is also why this bundle publishes one review document for the whole Host rather than one per workspace: the changes panel lists the turns of every session that changed files, so an agent left running in another project still reports where the reader already is.

The IDE side leans the same way. One companion serves the whole IDE: the chat panel keeps one session per project, the window junction can be told to register the shared parent so a multi-module checkout is one workspace (junctionRoot: common-parent), and jetbrains_workspace answers for every attached directory.

What that costs, measured rather than assumed: the companion descriptor is one file per user, and the companion starts one bridge per IDE run. Opening a second IDE window produced no second bridge on line, and the one descriptor already named both windows' projects. So a Host reaches every window through one bridge, DSH's workspace tool sees all of them, and the companion decides which window shows a diff or opens a file by matching the path against each project's base path. The Host also accepts a set of descriptors (the single one plus any jetbrains-companion/*.json beside it) and chooses by workspace, so a future build that publishes one descriptor per window needs no Host change.

What each half gives you

Each half is useful alone, and they do not depend on each other to install. What you get changes:

Capability	IDE plugin only	DSH bundle only	Both
DSH Chat tool window in the IDE (embedded DSH client, cookie auth)	yes	—	yes
One DSH session per IDE window, grouped in the DSH sidebar	yes — the panel registers the workspace and creates or attaches the session itself	—	yes
The model knows which IDE window is open (runtime context line)	—	yes, from the IDE's state files, or live when the companion runs	yes
jetbrains_workspace tool: root project, module content roots, active file, caret, selection	—	yes	yes
jetbrains_open_in_ide: the model opens a file in the IDE	—	no — it needs the companion's bridge	yes
Session selected without reloading the page	no — it seeds the client's stored selection and reloads once	—	yes, with jetbrains-session-link
Change review of a turn (which files, and their diffs)	—	yes — publishes <DSH home>/jetbrains-changes.json with the coordinates DSH's own /api/changes.* routes need	yes
A presented artifact opens in the IDE (present → editor tab)	—	opt-in — autoOpenDeliverables: true, and only for the window's own session	yes (needs the companion bridge)
A turn's changes as a native side-by-side IntelliJ diff	yes — the DSH Changes tool window	yes — publishes the document it reads	yes
A turn's diff opens by itself, with Keep / Revert	yes — POST /changed on the companion bridge	yes — posts the notice (autoOpenDiffs)	yes
Revert a file, or one hunk of it	yes — the panel and the notification action	—	yes
Turns published while the IDE was closed	yes — mentioned on the next start	yes — the document outlives the IDE	yes
Clicking a deliverable or changed file opens it in the IDE	—	the wrap is on by default (openInIde), but the IDE itself needs the companion's bridge — without one the desktop opener still runs	yes
Clicking a file in the DSH UI opens it in the IDE, not the DSH sidebar viewer	—	yes, on by default (openSidebarFilesInIde) — falls back to the sidebar	yes (needs the companion bridge)

So: install the IDE plugin to chat with DSH inside your IDE (it needs a DSH running locally, and reads DSH's credential document to sign the browser cookie — see SECURITY.md). Install the DSH bundle to put your IDE workspace in front of the model. Install both for the round trip, where the model can name the file you are editing and open another one for you.

The two halves talk through DSH's own HTTP API and the companion's descriptor (<DSH home>/jetbrains-companion.json, carrying a version and a source marker), so either half can be updated on its own: a bundle that finds no live descriptor falls back to the IDE's state files, and a companion never requires the bundle to be installed.

Install

git clone https://github.com/abadiegie/dsh-jetbrains.git

1. The IDE plugin (needs IntelliJ Platform build 243 or newer, with JCEF):

cd jetbrains-companion
./build.sh                 # compiles against the installed IDE and copies the jar into it
IDE_HOME=/path/to/idea ./build.sh

Then restart the IDE. Settings live under Settings ▸ Tools ▸ DSH Companion. Step 1 needs no DSH-side plugin; installing it alone gives you the chat panel (see the table above).

2. The DSH bundle (needs a DSH profile):

# from a DSH session: install the bundle directory into the current profile
plugin_manager install_bundle /absolute/path/to/jetbrains-workspace

Then restart DSH. jetbrains_workspace and jetbrains_open_in_ide become available to the agent; step 2 needs no IDE plugin, because the bundle reads the IDE's state files when no companion is publishing a descriptor. For the round trip — the model naming your active file and opening another — install both.

Documentation

• jetbrains-companion/README.md — the chat panel, session scope, discovery, settings, verification harnesses, limits.
• jetbrains-workspace/README.md — what it registers, where the data comes from, configuration, limits.
• jetbrains-session-link/README.md — the fragment contract, the marker a host reads, and what was verified in a browser and inside the IDE panel.
• SECURITY.md — what these plugins read and what they can do on your machine. Read this before installing.
• .dsh/skills/dsh-jetbrains/SKILL.md — a DeepSeek Harness skill for agents editing this repository: the build and check commands, and the traps worth knowing first. DSH scans <project>/.dsh/skills (and <project>/.agents/skills) around the nearest repository root, so a clone carries it and it is live for the agent working in that clone.
• docs/PUBLISHING.md — the checklist this repository was prepared against.
• CHANGELOG.md.

Requirements

• A JetBrains IDE, build 243+ (IC-243 or newer), with the bundled browser (JCEF).
• A JDK 21 toolchain for the IDE plugin build — the IDE's own JBR is enough.
• Node.js 20+ for the DSH bundle and its development checks.
• DSH from a version that exposes workspace/create returning sessionIds and created, workspace/rename, session/create with either cwd or workspaceId + sessionId, and workspace/archiveSession — the API surface both halves are written against.

Development

# DSH bundle, local acceptance: the tools against this machine's IDE state (needs the checkout)
cd jetbrains-workspace && node dev/check.mjs

# DSH bundle, hermetic: schema, discovery, roles, workspace registration, runtime context, review, opens
cd jetbrains-workspace && node dev/check-synthetic.mjs

# DSH bundle, client half: a file click asks the Host route, everything else keeps the sidebar
cd jetbrains-workspace && node dev/check-client.mjs

# IDE plugin: the IntelliJ-free half, the DSH client, the panel's auth path, address and scope rules
cd jetbrains-companion && ./build.sh
/usr/share/idea/jbr/bin/javac -cp build/stage -d build/check dev/*.java
/usr/share/idea/jbr/bin/java -cp build/stage:build/check Check

Every harness skips itself with a message when the DSH home, the server, or the IDE it needs is absent, so a missing dependency never looks like a failure.

License

MIT — see LICENSE.