Reverse engineer anything with agents, from app behavior down to native binaries.
TypeScript agent-skillsai-agentsbinary-analysisclaude-codeclicodexcordisdecompilerdeveloper-toolsdshdsh-pluginghidrahopperllmmcpmodel-context-protocolreareverse-engineeringstatic-analysistouhou
feat(setup): register DeepSeek Harness through setup, doctor and uninstall (#1929)
BaaRaid9d2a173819c
diff --git a/.agents/skills/reverse-engineer-anything/references/connection-and-recovery.md b/.agents/skills/reverse-engineer-anything/references/connection-and-recovery.mdindex 515a6c9d4..9b06a93fc 100644--- a/.agents/skills/reverse-engineer-anything/references/connection-and-recovery.md+++ b/.agents/skills/reverse-engineer-anything/references/connection-and-recovery.md@@ -46,7 +46,7 @@ rea setup --client codex --dry-run --jsonUse the current supported client's ID: `claude_code`, `claude_desktop`, `codex`,`cursor`, `gemini_cli`, `windsurf`, `devin`, `opencode`, `antigravity`,`copilot_cli`, `commandcode`, `qwen_code`, `vscode`, `grok_build`, `omp`, `pi`,-`hermes`, or `grok_bot`. If unknown, inspect `doctor --json` before choosing a+`hermes`, `dsh`, or `grok_bot`. If unknown, inspect `doctor --json` before choosing ascope. `grok_bot` uses a chat registration step rather than local `mcp.json`.For unsupported clients, use version-pinned manual stdio registration or CLI.diff --git a/docs/installation.md b/docs/installation.mdindex 720f1ae45..3c12d299b 100644--- a/docs/installation.md+++ b/docs/installation.md@@ -89,8 +89,11 @@ running server or its registration.The npm release checked on **2026-10-11** was **6.4.0**, published from[`a56f7bb6`](https://github.com/morluto/rea/commit/a56f7bb668ab23fec8d33f7af353ac7ed2fe1895).-The actual registry package accepted dry-run setup plans for all 17 client IDs-listed below, including Qwen Code, Pi and Hermes. OpenCode's plan selected+The actual registry package accepted dry-run setup plans for the 17 client IDs+in that release, including Qwen Code, Pi and Hermes. DeepSeek Harness (`dsh`)+is on main and is not in npm 6.4.0; `rea setup --client dsh` against `@latest`+reports an unsupported client until a release containing it is published.+OpenCode's plan selected`OPENCODE_CONFIG_DIR` even when that directory did not yet exist. These checksused an isolated home on macOS with Node 24; they verify planning and argumentadmission, without writing client configuration or establishing live integration@@ -162,6 +165,10 @@ listed after the table because its connector is not one of these files:| OMP | `omp` || Pi | `pi` || Hermes | `hermes` |+| DeepSeek Harness | `dsh` |++`dsh` is main-only until a release after 6.4.0. The registry check above does+not cover it.For GitHub Copilot CLI 1.0.95, `gpt-4.1` model metadata can block ordinarychat with REA's full input-schema profile before sending a model request@@ -259,11 +266,15 @@ configuration and skill destinations; doctor and uninstall use those same paths.### DeepSeek Harness-DeepSeek Harness uses a Cordis YAML patch sequence rather than a `mcpServers`-object. REA's `setup --client` does not edit this format. For Harness-`0.2.0-rc.2`, append the following entry to `$DSH_HOME/cordis.patch.yml`-(`~/.dsh/cordis.patch.yml` when `DSH_HOME` is unset). Preserve existing patches-and replace the executable paths with absolute paths from your installation:+DeepSeek Harness registers MCP clients through a Cordis YAML patch sequence+rather than a `mcpServers` object. `rea setup --client dsh` appends (or+replaces) the REA entry in the home patch `$DSH_HOME/cordis.patch.yml`+(`~/.dsh/cordis.patch.yml` when `DSH_HOME` is unset), preserving unrelated+patches and comments. `rea doctor --client dsh` checks that same entry id.+`rea uninstall` removes it by scanning supported clients; uninstall takes no+`--client` flag. The home patch applies to every Harness profile, so the+registration is written once and no per-profile edit is needed. The written+entry is:```yaml- insert:@@ -274,17 +285,20 @@ and replace the executable paths with absolute paths from your installation:transport: stdiocommand: /absolute/path/to/nodeargs: ["/absolute/path/to/rea/scripts/rea.mjs", mcp]- cwd: !!js process.cwd()```+Setup preserves caller-owned Cordis expressions and replaces launcher fields+with literal values that doctor can verify. It refuses to edit an expression+that produces the entire REA config, or a group-targeted REA insertion. Use a+literal config and a root-level insertion as shown above.+For a global npm installation, the launcher is under-`$(npm root -g)/rea-agents/scripts/rea.mjs`. Check the Node executable with-`command -v node`. Register `serverName: rea` only once in each active profile,-then restart Harness. It exposes tools as `mcp__rea__<tool_name>`.-Run `rea setup --skill --dry-run`, review the destination, then-`rea setup --skill --yes` to install the workflow in `~/.agents/skills`.-Harness discovers that directory, or `$DSH_AGENTS_HOME/skills` when configured;-its native `skill` tool can load `reverse-engineer-anything`.+`$(npm root -g)/rea-agents/scripts/rea.mjs`. Restart Harness after setup; it+exposes tools as `mcp__rea__<tool_name>`. Run `rea setup --skill --dry-run`,+review the destination, then `rea setup --skill --yes` to install the workflow+in `~/.agents/skills` (`$DSH_AGENTS_HOME/skills` when configured); Harness+discovers that directory, and its native `skill` tool can load+`reverse-engineer-anything`.REA's optional [native client verification](testing.md#end-to-end-integration-and-golden-evidence)checks headless chat, skill loading, all tool input schemas and actual analysisdiff --git a/docs/testing.md b/docs/testing.mdindex e62d91185..92cf8dc44 100644--- a/docs/testing.md+++ b/docs/testing.md@@ -272,9 +272,13 @@ unverified; skill discovery uses an explicit isolated custom directory.`verify:deepseek-client` requires an installed DeepSeek Harness (`dsh`;verified with `@deepseek-ai/[email protected]`) and Git. Set`REA_VERIFY_DEEPSEEK_COMMAND` to select its executable. This optional POSIX lane-installs the skill through `rea setup --skill`, writes the native Cordis MCP-patch into an isolated `DSH_HOME`, and binds `HOME` and `USERPROFILE` to the-disposable account. The native default `~/.agents/skills` search path discovers+seeds caller model settings and a stale Cordis registration in an isolated+`DSH_HOME`, then runs public `setup --client dsh` dry-run, setup, repeated setup,+and scoped doctor. It checks the backup and unrelated patches before booting+Harness with the generated registration. After native execution it uninstalls+through the public CLI and checks that only caller patches remain. `HOME` and+`USERPROFILE` point to the disposable account. The native default+`~/.agents/skills` search path discoversthe installed skill without a `DSH_AGENTS_HOME` override. A separate Git root prevents inherited project skills frommasking a missing installation. The default `call` mode checks skill loading,complete catalog discovery, the actual forwarded input schemas and regexes,@@ -285,6 +289,12 @@ context capacity declared by its default DeepSeek Flash model; it does notestablish live DeepSeek API or native Windows coverage. Receipts includerequest artifacts, result digests and owned-process lineage.+The DSH acceptance journey also exercises public setup, approval, doctor,+generated-launcher MCP startup and uninstall without an installed Harness.+That journey proves REA workflow behavior, not native Cordis expression+evaluation. Filesystem regressions retain tagged values and unrelated rows+across alias dependencies and check refusal of unsafe YAML without mutation.+Full E2E tests invoke the production command dispatcher and real providers,without fake launchers, runners or responses. `verify:keyed-archive` writesFoundation binary, XML, and integer archives using one run-owned Swift modulediff --git a/scripts/verify-deepseek-client.mjs b/scripts/verify-deepseek-client.mjsindex 12aed2a1e..42aae272b 100644--- a/scripts/verify-deepseek-client.mjs+++ b/scripts/verify-deepseek-client.mjs@@ -5,11 +5,12 @@ import { tmpdir } from "node:os";import { dirname, join } from "node:path";import { fileURLToPath } from "node:url";import { Ajv2020 } from "ajv/dist/2020.js";+import { parse as parseYaml } from "yaml";import {TOOL_CONTRACTS,toolContract,} from "../dist/contracts/toolContracts.js";-import { exec } from "./lib/verify-package-core.mjs";+import { exec, pathExists } from "./lib/verify-package-core.mjs";import { createVerifierRun, completeVerifierRun } from "./lib/verifier-run.mjs";import { createOpenAiModelFixture } from "./verify/clients/model-fixture.mjs";@@ -32,6 +33,7 @@ const skillPath = join("SKILL.md",);const cli = join(runtimeRoot, "scripts", "rea.mjs");+const configPath = join(profile, "cordis.patch.yml");const verifier = createVerifierRun();await Promise.all([mkdir(account),@@ -66,32 +68,32 @@ const clientVersion = (timeout: 30_000,})).stdout.trim();-for (const args of [- ["setup", "--skill", "--dry-run"],- ["setup", "--skill", "--yes"],-]) {+const lifecycle = [];+const runRea = async (args, artifact) => {const result = await exec(process.execPath, [cli, ...args, "--json"], {env: environment,cwd: workspace,timeout: 60_000,});- const parsed = JSON.parse(result.stdout);- assert.equal(parsed.status, args.includes("--dry-run") ? "planned" : "ready");- if (args.includes("--dry-run")) {- assert.equal(parsed.plannedActions.length, 1);- assert.equal(parsed.plannedActions[0].kind, "install_skill");- assert.equal(parsed.plannedActions[0].target, dirname(skillPath));- }- await writeFile(- join(lab, args.includes("--dry-run") ? "setup-plan.json" : "setup.json"),- result.stdout,- );-}-assert(- (await readFile(skillPath, "utf8")).includes(- "name: reverse-engineer-anything",- ),-);+ await writeFile(join(lab, `${artifact}.json`), result.stdout);+ return JSON.parse(result.stdout);+};+const patches = (text) =>+ parseYaml(text, {+ customTags: [+ {+ tag: "tag:yaml.org,2002:js",+ resolve: (source) => ({ __jsExpr: source }),+ },+ ],+ });+const withoutRea = (text) =>+ patches(text).flatMap((op) => {+ if (op.id === "rea-mcp") return [];+ if (!Array.isArray(op.insert)) return [op];+ const insert = op.insert.filter((entry) => entry.id !== "rea-mcp");+ return insert.length === 0 ? [] : [{ ...op, insert }];+ });let catalog;let patternCount = 0;@@ -247,10 +249,9 @@ const fixture = await createOpenAiModelFixture({});let failure;try {- // Use the client's native Cordis patch DSL; generic `rea setup --client` does not edit it.- await writeFile(- join(profile, "cordis.patch.yml"),- `+ // Seed model settings and a stale registration; the public setup workflow+ // must produce the registration this native client actually boots.+ const original = `- id: llm-pi-aiconfig:providers:@@ -275,13 +276,59 @@ try {config:serverName: reatransport: stdio- command: ${JSON.stringify(process.execPath)}- args: ${JSON.stringify([cli, "mcp"])}+ command: stale-launcher+ args: [mcp]cwd: !!js process.cwd()env:REA_PROCESS_RUN_ID: ${JSON.stringify(verifier.run_id)}-`,+`;+ await writeFile(configPath, original);+ const planned = await runRea(+ ["setup", "--client", "dsh", "--dry-run"],+ "setup-plan",);+ assert.equal(planned.status, "planned");+ assert(planned.plannedActions.some((action) => action.target === configPath));+ assert(+ planned.plannedActions.some(+ (action) => action.target === dirname(skillPath),+ ),+ );+ assert(+ planned.plannedActions.every(+ (action) =>+ action.target === configPath || action.target === dirname(skillPath),+ ),+ );+ assert.equal(await readFile(configPath, "utf8"), original);+ assert.equal(await pathExists(`${configPath}.rea.backup`), false);+ lifecycle.push("dry-run");+ const setup = await runRea(["setup", "--client", "dsh", "--yes"], "setup");+ assert.equal(setup.status, "ready");+ assert.equal(await readFile(`${configPath}.rea.backup`, "utf8"), original);+ const configured = await readFile(configPath, "utf8");+ assert.deepEqual(withoutRea(configured), withoutRea(original));+ assert(configured.includes("!!js process.cwd()"));+ assert(+ (await readFile(skillPath, "utf8")).includes(+ "name: reverse-engineer-anything",+ ),+ );+ lifecycle.push("setup");+ const repeated = await runRea(+ ["setup", "--client", "dsh", "--yes"],+ "setup-repeat",+ );+ assert.deepEqual(repeated.appliedActions, []);+ assert.equal(await readFile(configPath, "utf8"), configured);+ assert.equal(await readFile(`${configPath}.rea.backup`, "utf8"), original);+ lifecycle.push("idempotent-setup");+ const doctor = await runRea(+ ["doctor", "--client", "dsh", "--skill"],+ "doctor",+ );+ assert.equal(doctor.healthy, true);+ lifecycle.push("doctor");const execution = exec(command,[@@ -304,6 +351,20 @@ try {assert.equal(fixture.failure, undefined);assert(finalSeen && result.stdout.includes("REA_CLIENT_COMPATIBILITY_OK"));if (mode === "call") assert(evidenceSeen && skillLoaded);+ lifecycle.push(mode === "call" ? "native-tool-invocation" : "native-chat");+ const uninstall = await runRea(["uninstall"], "uninstall");+ assert.equal(uninstall.status, "complete");+ assert(+ uninstall.items.some(+ (item) => item.name === "dsh" && item.status === "removed",+ ),+ );+ assert.deepEqual(+ patches(await readFile(configPath, "utf8")),+ withoutRea(original),+ );+ assert.equal(await pathExists(skillPath), false);+ lifecycle.push("uninstall");} catch (cause) {failure = cause;if (typeof cause?.stdout === "string")@@ -316,6 +377,7 @@ try {client: "deepseek-harness",clientVersion,mode,+ lifecycle,passed: failure === undefined,artifacts: lab,runtimeRoot,diff --git a/src/application/ClientConfigurationDocument.ts b/src/application/ClientConfigurationDocument.tsindex 4ad037f07..65b4ba8de 100644--- a/src/application/ClientConfigurationDocument.ts+++ b/src/application/ClientConfigurationDocument.ts@@ -5,6 +5,13 @@ import {stringify as stringifyYaml,} from "yaml";import { isDeepStrictEqual } from "node:util";++import {+ parseDshCordisDocument,+ serializeDshDocument,+ editDshDocument,+ dshClientRegistrationEntry,+} from "./DshCordisPatch.js";import {applyEdits,findNodeAtLocation,@@ -131,6 +138,8 @@ export const parseClientConfiguration = (): ClientConfigurationDocument => {if (format === undefined || format === "unsupported")throw new TypeError("client does not have a supported MCP config format");+ // DeepSeek Harness stores a Cordis patch list, not a server table.+ if (format === "dsh") return parseDshCordisDocument(text);const document = parseDocument(text, format);const serversKey = clientConfigurationServersKey(format);const value = document[serversKey];@@ -184,6 +193,14 @@ export const withClientServers = (servers: Record<string, unknown>,removeLegacy?: string,): Record<string, unknown> => {+ // The Harness patch list upserts or removes by entry id, not by table.+ if (parsed.dialect === "dsh")+ return Object.hasOwn(servers, PRODUCT_IDENTITY.mcpServerKey)+ ? editDshDocument(+ parsed,+ objectSchema.parse(servers[PRODUCT_IDENTITY.mcpServerKey]),+ )+ : editDshDocument(parsed);const [key = "", nested] = parsed.serversPath;if (nested === undefined) return { ...parsed.document, [key]: servers };const outer = { ...objectSchema.parse(parsed.document[key]) };@@ -1280,6 +1297,7 @@ export const serializeClientConfiguration = (return serializeGrokConfiguration(document, originalText);if (format === "hermes")return serializeHermesConfiguration(document, originalText);+ if (format === "dsh") return serializeDshDocument(document);// An empty original holds no comments or settings to preserve. Writing a// fresh document also keeps a lone BOM from shifting past the closing brace.if (@@ -1398,6 +1416,8 @@ export const clientRegistrationEntry = (args,...(Object.keys(environment).length === 0 ? {} : { env: environment }),};+ case "dsh":+ return dshClientRegistrationEntry(command, environment);case "hermes":// Hermes reads stdio servers from `mcp_servers.<name>` and connects them// unless `enabled` is false, so the entry states it explicitly.diff --git a/src/application/ClientRegistrationEnvironment.ts b/src/application/ClientRegistrationEnvironment.tsindex 6048c2de1..86e95404d 100644--- a/src/application/ClientRegistrationEnvironment.ts+++ b/src/application/ClientRegistrationEnvironment.ts@@ -9,12 +9,15 @@ import {} from "./ClientConfigurationDocument.js";import { PRODUCT_IDENTITY } from "../identity.js";import { compareUnicodeCodePoints } from "../domain/unicodeCodePointOrder.js";+import { dshDocument } from "./DshCordisPatch.js";/** Read explicit REA overrides without dropping peers when one value is invalid. */export const clientRegistrationEnvironment = (parsed: ClientConfigurationDocument | undefined,overrides: Readonly<Record<string, string>> = {},): Result<Readonly<Record<string, string>>, ConfigurationError> => {+ if (parsed?.dialect === "dsh")+ return dshDocument(parsed.document).environment(overrides);const key =parsed?.dialect === "opencode" || parsed?.dialect === "opencode_v2"? "environment"diff --git a/src/application/ClientRegistrationStatus.ts b/src/application/ClientRegistrationStatus.tsindex 3b649c132..588b0f9af 100644--- a/src/application/ClientRegistrationStatus.ts+++ b/src/application/ClientRegistrationStatus.ts@@ -26,6 +26,7 @@ import {} from "./SupportedClients.js";import type { SetupClient } from "./SupportedClients.js";import { compareUnicodeCodePoints } from "../domain/unicodeCodePointOrder.js";+import { dshDocument } from "./DshCordisPatch.js";import type { ArtifactResourceScope } from "../artifacts/ArtifactResourceScope.js";interface ClientRegistrationStatusBase {@@ -66,6 +67,7 @@ const registrationSchema = zstartup_timeout_sec: z.number().positive().optional(),type: z.string().optional(),transport: z.string().optional(),+ serverName: z.string().optional(),tools: z.array(z.string()).optional(),disabled: z.boolean().optional(),enabled: z.boolean().optional(),@@ -178,6 +180,7 @@ export const readClientRegistrationStatuses = async (parsed,PRODUCT_IDENTITY.mcpServerKey,) &&+ (parsed.dialect !== "dsh" || dshDocument(parsed.document).ready) &&policyBlock === undefined? "aligned": "stale",@@ -221,6 +224,13 @@ const registrationAligned = ()return false;if (client.format === "vscode" && registration.type !== "stdio") return false;+ // A Harness registration only connects as the rea stdio server; another+ // server name or transport leaves the session without REA tools.+ if (+ client.format === "dsh" &&+ (registration.serverName !== "rea" || registration.transport !== "stdio")+ )+ return false;// OMP and Pi infer stdio for a command entry without an explicit type.if ((client.format === "omp" || client.format === "pi") &&@@ -264,6 +274,11 @@ const parseRegistration = (value: unknown,client: SetupClient,): z.output<typeof registrationSchema> => {+ if (client.format === "dsh")+ return registrationSchema+ .pick({ command: true, args: true, serverName: true, transport: true })+ .strip()+ .parse(value);if (client.format === "opencode") {const entry = z.object({diff --git a/src/application/DshCordisPatch.ts b/src/application/DshCordisPatch.tsnew file mode 100644index 000000000..81f7428fb--- /dev/null+++ b/src/application/DshCordisPatch.ts@@ -0,0 +1,375 @@+import { isMap, isSeq, type Node, type YAMLMap } from "yaml";+import { parseEnvironment } from "../config/environment.js";+import { ConfigurationError } from "../domain/configurationErrors.js";+import { err, ok, type Result } from "../domain/result.js";+import type { ClientConfigurationDocument } from "./ClientConfigurationDocument.js";+import { CordisExpression, DshCordisYaml } from "./DshCordisYaml.js";++export const DSH_ENTRY_ID = "rea-mcp";+export const DSH_CLIENT_PACKAGE = "@deepseek-ai/dsh-mcp-client";+const LAUNCHER_KEYS = new Set(["serverName", "transport", "command", "args"]);+const isRecord = (value: unknown): value is Record<string, unknown> =>+ typeof value === "object" &&+ value !== null &&+ !Array.isArray(value) &&+ !(value instanceof CordisExpression);++interface PatchOperation {+ readonly source: unknown;+ readonly map: YAMLMap<unknown, unknown>;+ readonly ownedRows: readonly number[];+ readonly direct: boolean;+}++/** One interpretation of identity, ordered patch applicability and source nodes. */+export class DshCordisDocument {+ readonly #yaml: DshCordisYaml;+ readonly #operations: readonly PatchOperation[];+ readonly #fields = new Map<string, unknown>();+ #entryNode: YAMLMap<unknown, unknown> | undefined;+ readonly #insertions: number;+ #unknownSelector = false;+ readonly config: Record<string, unknown> | undefined;++ constructor(text: string) {+ this.#yaml = new DshCordisYaml(text);+ const root = this.#yaml.document.contents;+ if (!isSeq(root))+ throw new ConfigurationError("Cordis patches must be a list");+ const operations: PatchOperation[] = [];+ let insertions = 0;+ for (const source of root.items) {+ const map = this.#map(source);+ if (map === undefined) continue;+ const inserted = this.#yaml.resolve(this.#yaml.field(map, "insert"));+ const targetId = this.#id(map);+ const ownedRows = isSeq(inserted)+ ? inserted.items.flatMap((entry, index) =>+ this.#id(entry) === DSH_ENTRY_ID ? [index] : [],+ )+ : [];+ const direct = !isSeq(inserted) && targetId === DSH_ENTRY_ID;+ if (ownedRows.length > 0 && targetId)+ throw new ConfigurationError(+ "Cannot establish the target group for a Cordis REA insertion from the home patch alone",+ );+ operations.push({ source, map, ownedRows, direct });+ if (isSeq(inserted)) {+ for (const index of ownedRows) {+ const entry = this.#map(inserted.items[index]);+ if (entry === undefined) continue;+ insertions += 1;+ this.#entryNode = entry;+ this.#fields.clear();+ this.#unknownSelector = false;+ this.#readFields(entry);+ }+ } else if (direct) {+ if (insertions === 0) continue;+ // Cordis uses name as a selector, not a rename operation.+ const selector = this.#yaml.value(this.#yaml.field(map, "name"));+ if (+ selector instanceof CordisExpression ||+ (selector && this.#field("name") instanceof CordisExpression)+ ) {+ this.#unknownSelector = true;+ continue;+ }+ if (selector && selector !== this.#field("name")) continue;+ this.#readFields(map, new Set(["id", "name"]));+ }+ }+ this.#operations = operations;+ this.#insertions = insertions;+ const config = this.#field("config");+ // Ownership survives malformed config so uninstall can remove the source row.+ this.config = insertions === 0 ? undefined : isRecord(config) ? config : {};+ }++ #map(node: unknown): YAMLMap<unknown, unknown> | undefined {+ const map = this.#yaml.resolve(node);+ return isMap(map) ? map : undefined;+ }+ #id(node: unknown): unknown {+ const id = this.#yaml.value(this.#yaml.field(this.#map(node), "id"));+ if (id instanceof CordisExpression)+ throw new ConfigurationError(+ "Expression-backed Cordis IDs have unknown ownership; use literal IDs before changing registrations",+ );+ return id;+ }+ #field(key: string): unknown {+ return this.#yaml.value(this.#fields.get(key));+ }+ #readFields(+ map: YAMLMap<unknown, unknown>,+ omitted: ReadonlySet<string> = new Set(),+ ): void {+ for (const pair of map.items) {+ const key = this.#yaml.value(pair.key);+ if (typeof key === "string" && !omitted.has(key))+ this.#fields.set(key, pair.value);+ }+ }+ get carriesEntry(): boolean {+ return this.#operations.some((op) => op.direct || op.ownedRows.length > 0);+ }+ get ready(): boolean {+ const disabled = this.#field("disabled");+ return (+ this.#insertions === 1 &&+ !this.#unknownSelector &&+ this.#field("name") === DSH_CLIENT_PACKAGE &&+ (disabled === undefined || disabled === false)+ );+ }++ /** Validate literals without treating expression source as an environment value. */+ environment(+ overrides: Readonly<Record<string, string>> = {},+ ): Result<Readonly<Record<string, string>>, ConfigurationError> {+ if (this.#unknownSelector)+ return err(+ new ConfigurationError(+ "Expression-backed Cordis name selectors have unknown applicability; use literal selectors before setup",+ {+ settings: [+ {+ setting: "name",+ constraint: "Use literal selectors before setup",+ },+ ],+ },+ ),+ );+ const config = this.#field("config");+ if (config instanceof CordisExpression)+ return err(+ new ConfigurationError(+ "Expression-backed Cordis config cannot be safely edited",+ {+ settings: [+ {+ setting: "config",+ constraint:+ "Use a literal mapping to preserve caller fields during setup",+ },+ ],+ },+ ),+ );+ if (config !== undefined && !isRecord(config))+ return err(+ new ConfigurationError("Cordis REA config must be a mapping", {+ settings: [+ {+ setting: "config",+ constraint: "Use a literal mapping before setup",+ },+ ],+ }),+ );+ const raw = this.config?.env;+ if (raw !== undefined && !isRecord(raw))+ return err(+ new ConfigurationError("Cordis server environment must be a mapping"),+ );+ const literals: Record<string, string> = {};+ for (const [key, value] of Object.entries(raw ?? {})) {+ if (value instanceof CordisExpression) continue;+ if (typeof value !== "string")+ return err(+ new ConfigurationError("Invalid Cordis server environment", {+ settings: [+ {+ setting: `env.${key}`,+ constraint:+ "Environment values must be strings or Cordis expressions",+ },+ ],+ }),+ );+ literals[key] = value;+ }+ const environment = { ...literals, ...overrides };+ const validated = parseEnvironment(environment);+ return validated.ok ? ok(environment) : validated;+ }++ desired(+ command: readonly string[],+ overrides: Readonly<Record<string, string>>,+ ): Result<Record<string, unknown>, ConfigurationError> {+ const environment = this.environment(overrides);+ if (!environment.ok) return environment;+ const env = {+ ...(isRecord(this.config?.env) ? this.config.env : {}),+ ...overrides,+ };+ const desired = { ...this.config, ...dshClientRegistrationEntry(command) };+ delete desired.env;+ if (Object.keys(env).length > 0) desired.env = env;+ return ok(desired);+ }++ /** Plan every replacement from source snapshots before changing an output tree. */+ serialize(desired?: Record<string, unknown>): string {+ const root = this.#yaml.document.contents;+ if (!isSeq(root))+ throw new ConfigurationError("Cordis patches must be a list");+ const replacements = new Map<unknown, unknown>();+ const invalidated = new Set(+ this.#operations.flatMap((op) =>+ op.direct || op.ownedRows.length > 0+ ? this.#yaml.anchors(op.source)+ : [],+ ),+ );+ let carried = false;+ for (const op of this.#operations) {+ if (op.direct) {+ replacements.set(op.source, undefined);+ continue;+ }+ if (op.ownedRows.length === 0) continue;+ const copy = this.#yaml.detach(op.map, invalidated);+ if (!isMap(copy))+ throw new ConfigurationError("Cordis operation is not a mapping");+ const inserted = this.#yaml.detach(+ this.#yaml.resolve(this.#yaml.field(op.map, "insert")),+ invalidated,+ );+ if (!isSeq(inserted))+ throw new ConfigurationError("Cordis insertion is not a list");+ copy.set("insert", inserted);+ const owned = new Set(op.ownedRows);+ inserted.items = inserted.items.flatMap((entry, index) => {+ if (!owned.has(index)) return [entry];+ if (carried || desired === undefined) return [];+ carried = true;+ return [this.#entry(desired, invalidated)] as typeof inserted.items;+ });+ replacements.set(+ op.source,+ inserted.items.length === 0 ? undefined : copy,+ );+ }+ const output = this.#yaml.document.clone();+ const outputRoot = output.contents;+ if (!isSeq(outputRoot))+ throw new ConfigurationError("Cordis patches must be a list");+ outputRoot.items = root.items.flatMap((source) => {+ const copy = replacements.has(source)+ ? replacements.get(source)+ : this.#yaml.copy(source, invalidated);+ return copy === undefined ? [] : [copy];+ }) as typeof outputRoot.items;+ if (!carried && desired !== undefined)+ outputRoot.items.push(+ output.createNode({+ insert: [+ { id: DSH_ENTRY_ID, name: DSH_CLIENT_PACKAGE, config: desired },+ ],+ }) as never,+ );+ return output.toString({ lineWidth: 0 });+ }++ #entry(+ desired: Record<string, unknown>,+ invalidated: ReadonlySet<Node>,+ ): YAMLMap<unknown, unknown> {+ const entry = this.#yaml.detach(this.#entryNode, invalidated);+ if (!isMap(entry))+ throw new ConfigurationError("Cordis entry is not a mapping");+ this.#yaml.setValue(entry, "id", DSH_ENTRY_ID);+ this.#yaml.setValue(entry, "name", DSH_CLIENT_PACKAGE);+ entry.delete("disabled");+ for (const [key, value] of this.#fields) {+ if (["id", "name", "config", "disabled"].includes(key)) continue;+ entry.set(key, this.#yaml.detach(value, invalidated));+ }+ const sourceConfig = this.#map(this.#fields.get("config"));+ const config =+ sourceConfig === undefined+ ? this.#yaml.document.createNode({})+ : this.#yaml.detach(sourceConfig, invalidated);+ if (!isMap(config))+ throw new ConfigurationError(+ "Cordis registration config is not a mapping",+ );+ // Caller nodes keep their tags and spelling; only literal launcher values change.+ for (const key of LAUNCHER_KEYS)+ this.#yaml.setValue(config, key, desired[key]);+ const env = this.#map(this.#yaml.field(sourceConfig, "env"));+ const desiredEnv = desired.env;+ if (isRecord(desiredEnv)) {+ const nextEnv =+ env === undefined+ ? this.#yaml.document.createNode({})+ : this.#yaml.detach(env, invalidated);+ if (!isMap(nextEnv))+ throw new ConfigurationError("Cordis environment is not a mapping");+ for (const [key, value] of Object.entries(desiredEnv)) {+ this.#yaml.setValue(nextEnv, key, value);+ }+ config.set("env", nextEnv);+ } else config.delete("env");+ entry.set("config", config);+ return entry;+ }+}++class DshCordisEdit {+ constructor(+ readonly source: DshCordisDocument,+ readonly desired?: Record<string, unknown>,+ ) {}+}+export const dshDocument = (+ document: Record<string, unknown>,+): DshCordisDocument => {+ if (!(document.cordis instanceof DshCordisDocument))+ throw new ConfigurationError("Missing Cordis document owner");+ return document.cordis;+};+export const parseDshCordisDocument = (+ text: string,+): ClientConfigurationDocument => {+ const source = new DshCordisDocument(text);+ return {+ document: { cordis: source },+ servers: source.config === undefined ? {} : { rea: source.config },+ serversPath: [],+ dialect: "dsh",+ legacyServers: {},+ };+};+export const editDshDocument = (+ parsed: ClientConfigurationDocument,+ desired?: Record<string, unknown>,+): Record<string, unknown> => ({+ cordis: new DshCordisEdit(dshDocument(parsed.document), desired),+});+export const serializeDshDocument = (+ document: Record<string, unknown>,+): string => {+ if (!(document.cordis instanceof DshCordisEdit))+ throw new ConfigurationError("Missing Cordis edit plan");+ return document.cordis.source.serialize(document.cordis.desired);+};+export const dshClientRegistrationEntry = (+ command: readonly string[],+ environment: Readonly<Record<string, string>> = {},+): Record<string, unknown> => {+ const [executable = "rea", ...args] = command;+ return {+ serverName: "rea",+ transport: "stdio",+ command: executable,+ args,+ ...(Object.keys(environment).length === 0+ ? {}+ : { env: { ...environment } }),+ };+};diff --git a/src/application/DshCordisYaml.ts b/src/application/DshCordisYaml.tsnew file mode 100644index 000000000..ea84e5e65--- /dev/null+++ b/src/application/DshCordisYaml.ts@@ -0,0 +1,175 @@+import { isDeepStrictEqual } from "node:util";+import {+ isAlias,+ isMap,+ isNode,+ isScalar,+ isSeq,+ parseDocument,+ visit,+ type Document,+ type Node,+ type YAMLMap,+} from "yaml";+import { ConfigurationError } from "../domain/configurationErrors.js";++/** Expression source is never a literal value and is never evaluated by REA. */+export class CordisExpression {+ readonly kind = "cordis-expression";+ constructor(readonly source: string) {}+}++/** Immutable source graph; all alias resolution happens against this document. */+export class DshCordisYaml {+ readonly document: Document;+ readonly #values = new Map<Node, unknown>();+ readonly #visiting = new Set<Node>();++ constructor(text: string) {+ this.document = parseDocument(text, {+ customTags: [+ { tag: "tag:yaml.org,2002:js", resolve: (source: string) => source },+ ],+ logLevel: "silent",+ });+ if (this.document.errors.length > 0 || this.document.warnings.length > 0)+ throw new ConfigurationError("Invalid or unsupported Cordis YAML", {+ cause: this.document.errors[0] ?? this.document.warnings[0],+ });+ if (this.document.contents === null)+ this.document.contents = this.document.createNode([]);+ if (!isSeq(this.document.contents))+ throw new ConfigurationError(+ "Cordis patches must be a YAML operation list",+ );+ this.value(this.document.contents);+ try {+ // Retain YAML's native alias-expansion admission before copying edits.+ // This value is discarded; source nodes own every Cordis interpretation.+ this.document.toJS();+ } catch (cause) {+ throw new ConfigurationError("Unsafe Cordis YAML alias expansion", {+ cause,+ });+ }+ }++ resolve(node: unknown): unknown {+ if (!isAlias(node)) return node;+ const resolved = node.resolve(this.document);+ if (resolved === undefined)+ throw new ConfigurationError("Cordis YAML contains an unresolved alias");+ return resolved;+ }++ value(node: unknown): unknown {+ const resolved = this.resolve(node);+ if (!isNode(resolved)) return resolved;+ if (this.#values.has(resolved)) return this.#values.get(resolved);+ if (this.#visiting.has(resolved))+ throw new ConfigurationError(+ "Cyclic Cordis YAML cannot be safely edited",+ );+ this.#visiting.add(resolved);+ let value: unknown;+ if (isScalar(resolved))+ value =+ resolved.tag === "tag:yaml.org,2002:js"+ ? new CordisExpression(String(resolved.value))+ : resolved.value;+ else if (isSeq(resolved))+ value = resolved.items.map((item) => this.value(item));+ else if (isMap(resolved)) {+ const entries: [string, unknown][] = [];+ for (const pair of resolved.items) {+ entries.push([this.#key(pair.key), this.value(pair.value)]);+ }+ value = Object.fromEntries(entries);+ }+ this.#visiting.delete(resolved);+ this.#values.set(resolved, value);+ return value;+ }++ #key(node: unknown): string {+ const key = this.value(node);+ if (typeof key === "object" && key !== null)+ throw new ConfigurationError(+ "Cordis YAML mapping keys must be literal scalars",+ );+ // Match YAML's JS object projection while retaining the original key node.+ return key === null ? "" : String(key);+ }++ field(map: YAMLMap | undefined, key: string): unknown {+ return map?.items.findLast((pair) => this.#key(pair.key) === key)?.value;+ }++ /** Preserve unchanged nodes and carry their comments when replacing values. */+ setValue(map: YAMLMap, key: string, value: unknown): void {+ const original = this.field(map, key);+ if (isDeepStrictEqual(this.value(original), value)) return;+ const replacement = this.document.createNode(value);+ if (isNode(original) && isNode(replacement)) {+ if (original.comment !== undefined)+ replacement.comment = original.comment;+ if (original.commentBefore !== undefined)+ replacement.commentBefore = original.commentBefore;+ }+ map.set(key, replacement);+ }++ /** Copy from the source before edits; materialized nodes own no anchors. */+ copy(node: unknown, invalidated?: ReadonlySet<Node>): unknown {+ if (isAlias(node)) {+ const target = this.resolve(node);+ return invalidated === undefined ||+ (isNode(target) && invalidated.has(target))+ ? this.copy(target)+ : node.clone();+ }+ if (!isNode(node)) return node;+ const copied = node.clone();+ if (+ (invalidated === undefined || invalidated.has(node)) &&+ (isScalar(copied) || isMap(copied) || isSeq(copied))+ )+ delete copied.anchor;+ if (isSeq(node) && isSeq(copied))+ copied.items = node.items.map((item) =>+ this.copy(item, invalidated),+ ) as typeof copied.items;+ if (isMap(node) && isMap(copied))+ copied.items.forEach((pair, index) => {+ pair.key = this.copy(node.items[index]!.key, invalidated);+ pair.value = this.copy(node.items[index]!.value, invalidated);+ });+ return copied;+ }++ /** Replacing an anchor must not change untouched consumers of its old value. */+ detach(node: unknown, invalidated: ReadonlySet<Node>): unknown {+ const copied = this.copy(node, invalidated);+ if (isNode(copied))+ visit(copied, {+ Pair: (_key, pair) => {+ if (isAlias(pair.key)) pair.key = this.copy(this.resolve(pair.key));+ },+ Value: (_key, value) => {+ delete value.anchor;+ },+ });+ return copied;+ }++ anchors(node: unknown): readonly Node[] {+ if (!isNode(node)) return [];+ const anchors: Node[] = [];+ visit(node, {+ Value: (_key, value) => {+ if (value.anchor) anchors.push(value);+ },+ });+ return anchors;+ }+}diff --git a/src/application/SetupClientConfiguration.ts b/src/application/SetupClientConfiguration.tsindex 3f18d5023..ac493282a 100644--- a/src/application/SetupClientConfiguration.ts+++ b/src/application/SetupClientConfiguration.ts@@ -12,6 +12,7 @@ import {withClientServers,type ClientConfigurationDocument,} from "./ClientConfigurationDocument.js";+import { dshDocument, DshCordisDocument } from "./DshCordisPatch.js";import { constants as fsConstants } from "node:fs";import { copyFile, mkdir, rm, writeFile } from "node:fs/promises";import { dirname } from "node:path";@@ -89,7 +90,10 @@ const configureClientDocument = async (let parsed: ClientConfigurationDocument;try {parsed = parseClientConfiguration(- original ?? (format === "toml" || format === "grok" ? "" : "{}"),+ original ??+ (format === "toml" || format === "grok" || format === "dsh"+ ? ""+ : "{}"),format,);const policy = await readClientPolicyBlock(@@ -396,6 +400,7 @@ const registrationCurrent = (parsed: ClientConfigurationDocument,desired: unknown,): boolean =>+ (parsed.dialect !== "dsh" || dshDocument(parsed.document).ready) &&clientConfigurationValuesEqual(parsed.servers[PRODUCT_IDENTITY.mcpServerKey],desired,@@ -410,6 +415,17 @@ const clientConfigurationDesired = (parsed?: ClientConfigurationDocument,) => {const format = parsed?.dialect ?? client.format ?? "json";+ const launcher =+ command.length === 0 ? [PRODUCT_IDENTITY.cliBinary, "mcp"] : command;+ if (format === "dsh") {+ const desired = (+ parsed === undefined+ ? new DshCordisDocument("")+ : dshDocument(parsed.document)+ ).desired(launcher, providerEnvironment);+ if (!desired.ok) throw desired.error;+ return desired.value;+ }// Preserve explicitly configured server settings, never the ambient process// environment. Newly discovered provider paths win only for their own keys.const environment = clientRegistrationEnvironment(@@ -419,7 +435,7 @@ const clientConfigurationDesired = (if (!environment.ok) throw environment.error;const registration = clientRegistrationEntry(format,- command.length === 0 ? [PRODUCT_IDENTITY.cliBinary, "mcp"] : command,+ launcher,environment.value,);return {diff --git a/src/application/SupportedClients.ts b/src/application/SupportedClients.tsindex c4b0bc6e9..b44e5017a 100644--- a/src/application/SupportedClients.ts+++ b/src/application/SupportedClients.ts@@ -38,6 +38,7 @@ export interface SetupClient {| "omp"| "pi"| "hermes"+ | "dsh"| "unsupported";}@@ -129,6 +130,12 @@ const qwenCodeDirectory = ({ home, env }: ClientPathContext): string => {const grokDirectory = ({ home, env }: ClientPathContext): string =>env.GROK_HOME || join(home, ".grok");+const dshHomeDirectory = ({ home, env }: ClientPathContext): string =>+ env.DSH_HOME ?? join(home, ".dsh");++const dshPatchDirectory = (context: ClientPathContext): string =>+ join(dshHomeDirectory(context), "cordis.patch.yml");+const hermesDirectory = ({ home, platform, env }: ClientPathContext): string =>resolveHermesClientHome(home, platform, env);@@ -492,6 +499,17 @@ export const SUPPORTED_CLIENT_DEFINITIONS = [markerPath: hermesDirectory,format: "hermes",},+ {+ name: "dsh",+ displayName: "DeepSeek Harness",+ // The home Cordis patch applies to every profile; the skill directory is+ // shared agent storage Harness discovers.+ skillPath: ({ home, env }: ClientPathContext) =>+ join(env.DSH_AGENTS_HOME ?? join(home, ".agents"), "skills"),+ configPath: dshPatchDirectory,+ markerPath: dshHomeDirectory,+ format: "dsh",+ },{name: "grok_bot",displayName: "Grok Bot",diff --git a/src/application/Uninstall.ts b/src/application/Uninstall.tsindex abcb61ac3..d474419a8 100644--- a/src/application/Uninstall.ts+++ b/src/application/Uninstall.ts@@ -22,6 +22,7 @@ import {skillDestinations,} from "./SetupSkill.js";import { isOwnedClientRegistrationCommand } from "./ClientRegistrationIdentity.js";+import { dshDocument } from "./DshCordisPatch.js";import { resolveClientConfigTransactionPath } from "./ClientConfigPath.js";import { readRegularFileText } from "./RegularFileRead.js";import { ArtifactResourceScope } from "../artifacts/ArtifactResourceScope.js";@@ -305,10 +306,15 @@ const removeClient = async (// Beside a native OpenCode V2 table, OpenCode also loads a V1 `mcp.rea`.const legacyPath = legacyClientServerPath(parsed, name);const hasNative = Object.hasOwn(parsed.servers, name);- if (!hasNative && legacyPath === undefined)+ // Harness ownership is the stable entry id. A stale or malformed launcher+ // still belongs to that id, and so does a direct patch that projects no row.+ const carriesDshEntry =+ parsed.dialect === "dsh" && dshDocument(parsed.document).carriesEntry;+ if (!hasNative && legacyPath === undefined && !carriesDshEntry)return item(client.name, "skipped", "REA registration is absent.");const removeNative =- hasNative && isOwnedRegistration(parsed.servers[name], client);+ carriesDshEntry ||+ (hasNative && isOwnedRegistration(parsed.servers[name], client));const removeLegacy =legacyPath !== undefined &&isOwnedRegistration(parsed.legacyServers[name], client);@@ -356,6 +362,8 @@ const removeClient = async ();if ((removeNative && Object.hasOwn(readback.servers, name)) ||+ (readback.dialect === "dsh" &&+ dshDocument(readback.document).carriesEntry) ||(removeLegacy && Object.hasOwn(readback.legacyServers, name)))throw new Error("registration readback mismatch");diff --git a/tests/acceptance/setup/dshClientSetup.test.ts b/tests/acceptance/setup/dshClientSetup.test.tsnew file mode 100644index 000000000..1ee935da6--- /dev/null+++ b/tests/acceptance/setup/dshClientSetup.test.ts@@ -0,0 +1,232 @@+import { mkdir, readFile, writeFile } from "node:fs/promises";+import { join } from "node:path";+import { Client } from "@modelcontextprotocol/client";+import { StdioClientTransport } from "@modelcontextprotocol/client/stdio";+import { expect } from "vitest";+import { parse } from "yaml";+import { z } from "zod";+import { createTestTempDirectory } from "../../fixtures/temporaryDirectory.js";+import { cliTest } from "../../support/cli/cliFixture.js";++cliTest(+ "DSH CLI previews, approves, repairs, launches MCP, repeats and uninstalls while preserving caller YAML",+ async ({ cli }) => {+ const home = await createTestTempDirectory("rea-dsh-lifecycle-");+ const profile = join(home, "selected harness");+ const config = join(profile, "cordis.patch.yml");+ const skill = join(+ home,+ ".agents/skills/reverse-engineer-anything/SKILL.md",+ );+ await mkdir(profile);+ const original = `# caller home patch+- insert:+ - id: rea-mcp+ name: '@deepseek-ai/dsh-mcp-client'+ config: {serverName: rea, transport: stdio, command: stale, args: [mcp]}+- holder: &op+ insert:+ - id: unrelated+ name: caller-plugin+ disabled: true+ config: {cwd: !!js process.cwd()}+ - id: rea-mcp+ name: '@deepseek-ai/dsh-mcp-client'+ config:+ serverName: rea+ transport: stdio+ command: stale+ args: [mcp]+ cwd: !!js process.cwd()+ env:+ REA_LOG_LEVEL: !!js process.env.REA_LOG_LEVEL+- *op+`;+ await writeFile(config, original);+ const environment = { HOME: home, USERPROFILE: home, DSH_HOME: profile };+ const run = (args: readonly string[]) =>+ cli.run({+ arguments: [...args, "--json"],+ cwd: home,+ environment,+ timeoutMs: 20_000,+ });+ const plan = await run(["setup", "--client", "dsh", "--dry-run"]);+ expect(plan.exitCode).toBe(0);+ expect(plan.json).toMatchObject({+ status: "planned",+ appliedActions: [],+ plannedActions: expect.arrayContaining([+ expect.objectContaining({ id: "configure_client:dsh", target: config }),+ expect.objectContaining({ id: "install_skill" }),+ ]),+ });+ expect(await readFile(config, "utf8")).toBe(original);+ await expect(readFile(`${config}.rea.backup`)).rejects.toMatchObject({+ code: "ENOENT",+ });+ const unapproved = await run(["setup", "--client", "dsh"]);+ expect(unapproved.json).toMatchObject({+ status: "needs_confirmation",+ appliedActions: [],+ });+ expect(await readFile(config, "utf8")).toBe(original);+ const configured = await run(["setup", "--client", "dsh", "--yes"]);+ expect(configured.exitCode).toBe(0);+ expect(configured.json).toMatchObject({+ status: "ready",+ clients: { dsh: { status: "configured" } },+ });+ const text = await readFile(config, "utf8");+ expect(text).toContain("# caller home patch");+ const patches = parse(text, {+ customTags: [+ {+ tag: "tag:yaml.org,2002:js",+ resolve: (source: string) => ({ __jsExpr: source }),+ },+ ],+ }) as { insert?: { id: string; config: unknown }[] }[];+ const rows = patches.flatMap((patch) => patch.insert ?? []);+ expect(rows.filter(({ id }) => id === "unrelated")).toEqual([+ {+ id: "unrelated",+ name: "caller-plugin",+ disabled: true,+ config: { cwd: { __jsExpr: "process.cwd()" } },+ },+ ]);+ expect(rows.filter(({ id }) => id === "rea-mcp")).toHaveLength(1);+ const registration = z+ .object({+ command: z.string(),+ args: z.array(z.string()),+ cwd: z.unknown(),+ env: z.unknown(),+ })+ .parse(rows.find(({ id }) => id === "rea-mcp")?.config);+ expect(registration.cwd).toEqual({ __jsExpr: "process.cwd()" });+ expect(registration.env).toMatchObject({+ REA_LOG_LEVEL: { __jsExpr: "process.env.REA_LOG_LEVEL" },+ });+ const doctor = await run(["doctor", "--client", "dsh", "--skill"]);+ expect(doctor.exitCode).toBe(0);+ expect(doctor.json).toMatchObject({+ healthy: true,+ identity: {+ registrations: expect.arrayContaining([+ expect.objectContaining({ client: "dsh", state: "aligned" }),+ ]),+ },+ });+ await verifyGeneratedLauncher(registration, home, environment);+ const repeated = await run(["setup", "--client", "dsh", "--yes"]);+ expect(repeated.json).toMatchObject({+ status: "ready",+ appliedActions: [],+ plannedActions: [],+ });+ expect(await readFile(config, "utf8")).toBe(text);+ expect(await readFile(`${config}.rea.backup`, "utf8")).toBe(original);+ const removed = await run(["uninstall"]);+ expect(removed.exitCode).toBe(0);+ expect(removed.json).toMatchObject({+ status: "complete",+ items: expect.arrayContaining([+ expect.objectContaining({ name: "dsh", status: "removed" }),+ ]),+ });+ const remaining = parse(await readFile(config, "utf8"), {+ logLevel: "silent",+ }) as { insert?: { id: string }[] }[];+ expect(+ remaining.flatMap((patch) => patch.insert ?? []).map(({ id }) => id),+ ).toEqual(["unrelated"]);+ expect(await readFile(`${config}.rea.backup`, "utf8")).toBe(original);+ await expect(readFile(skill)).rejects.toMatchObject({ code: "ENOENT" });+ },+);++async function verifyGeneratedLauncher(+ registration: { command: string; args: string[] },+ home: string,+ environment: Record<string, string>,+): Promise<void> {+ // Exercise the generated launcher. Native Cordis expression evaluation belongs+ // to verify:deepseek-client, not this SDK transport journey.+ const transport = new StdioClientTransport({+ command: registration.command,+ args: registration.args,+ cwd: home,+ env: { PATH: process.env.PATH ?? "", ...environment },+ stderr: "pipe",+ });+ const client = new Client({ name: "dsh-setup-lifecycle", version: "1" });+ try {+ await client.connect(transport);+ expect((await client.listTools()).tools.map(({ name }) => name)).toContain(+ "binary_session",+ );+ const session = await client.callTool({+ name: "binary_session",+ arguments: {},+ });+ expect(session.isError).not.toBe(true);+ expect(session.structuredContent).toMatchObject({+ result: { open: false },+ });+ } finally {+ await client.close();+ await transport.close();+ }+}++cliTest.for(["null", "caller-value", "[caller-value]"])(+ "DSH CLI refuses to edit config %s and plain uninstall removes its owned row",+ async (configValue, { cli }) => {+ const home = await createTestTempDirectory("rea-dsh-malformed-config-");+ const profile = join(home, ".dsh");+ const config = join(profile, "cordis.patch.yml");+ await mkdir(profile);+ const initial = `# caller patch+- insert:+ - id: other+ name: caller-plugin+ - id: rea-mcp+ name: '@deepseek-ai/dsh-mcp-client'+ config: ${configValue}+`;+ await writeFile(config, initial);+ const run = (args: readonly string[]) =>+ cli.run({+ arguments: [...args, "--json"],+ cwd: home,+ environment: { HOME: home, USERPROFILE: home, DSH_HOME: profile },+ });+ const configured = await run(["setup", "--client", "dsh", "--yes"]);+ expect(configured.exitCode).not.toBe(0);+ expect(configured.json).toMatchObject({+ status: "needs_human",+ appliedActions: [],+ remediation: expect.stringContaining("config: Use a literal mapping"),+ });+ expect(await readFile(config, "utf8")).toBe(initial);+ await expect(readFile(`${config}.rea.backup`)).rejects.toMatchObject({+ code: "ENOENT",+ });+ const removed = await run(["uninstall"]);+ expect(removed.exitCode).toBe(0);+ expect(removed.json).toMatchObject({+ status: "complete",+ items: expect.arrayContaining([+ expect.objectContaining({ name: "dsh", status: "removed" }),+ ]),+ });+ const remaining = await readFile(config, "utf8");+ expect(remaining).toContain("# caller patch");+ expect(parse(remaining)).toEqual([+ { insert: [{ id: "other", name: "caller-plugin" }] },+ ]);+ expect(await readFile(`${config}.rea.backup`, "utf8")).toBe(initial);+ },+);diff --git a/tests/boundary/filesystem/clientLifecycle.test.ts b/tests/boundary/filesystem/clientLifecycle.test.tsindex 9b3e8f5b9..db0b517e7 100644--- a/tests/boundary/filesystem/clientLifecycle.test.ts+++ b/tests/boundary/filesystem/clientLifecycle.test.ts@@ -67,6 +67,7 @@ describe("client configuration filesystem lifecycle", () => {"omp","pi","hermes",+ "dsh","grok_bot",]);expect(diff --git a/tests/boundary/filesystem/dshClientConfiguration.test.ts b/tests/boundary/filesystem/dshClientConfiguration.test.tsnew file mode 100644index 000000000..c33354b40--- /dev/null+++ b/tests/boundary/filesystem/dshClientConfiguration.test.ts@@ -0,0 +1,2062 @@+import { mkdir, readFile, writeFile } from "node:fs/promises";+import { join } from "node:path";++import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";+import {+ isNode,+ isSeq,+ parseDocument,+ parse as parseYaml,+ stringify as stringifyYaml,+} from "yaml";++import { readClientRegistrationStatuses } from "../../../src/application/ClientRegistrationStatus.js";+import { npxRegistrationCommand } from "../../../src/application/ClientRegistrationIdentity.js";+import { configureClientConfiguration } from "../../../src/application/SetupClientConfiguration.js";+import {+ clientSkillDirectories,+ supportedClients,+} from "../../../src/application/SupportedClients.js";+import { systemUninstallHost } from "../../../src/application/Uninstall.js";+import { createTestTempDirectory } from "../../fixtures/temporaryDirectory.js";+import { clearClientLocationEnvironment } from "../../fixtures/clientEnvironment.js";++/**+ * The registration command setup writes on the host running the tests. Windows+ * wraps it in `cmd.exe /d /c`, so the expected entry follows the host too.+ */+const command = npxRegistrationCommand(process.platform);++beforeEach(clearClientLocationEnvironment);+afterEach(() => vi.unstubAllEnvs());++const dshClient = (+ env: Parameters<typeof supportedClients>[2],+ platform: NodeJS.Platform = "linux",+) =>+ supportedClients(join("/home/a"), platform, env).find(+ ({ name }) => name === "dsh",+ );++describe("DeepSeek Harness configuration paths", () => {+ it("resolves the home Cordis patch under the Harness home", () => {+ expect(dshClient({})).toEqual({+ name: "dsh",+ displayName: "DeepSeek Harness",+ configPath: join("/home/a", ".dsh", "cordis.patch.yml"),+ markerPath: join("/home/a", ".dsh"),+ format: "dsh",+ });+ // The home patch applies to every profile; DSH_HOME relocates it.+ expect(dshClient({ DSH_HOME: "/custom/harness" })?.configPath).toBe(+ join("/custom/harness", "cordis.patch.yml"),+ );+ expect(+ clientSkillDirectories(join("/home/a"), ["dsh"], {+ DSH_AGENTS_HOME: "/custom/agents",+ }),+ ).toEqual([{ client: "dsh", directory: join("/custom/agents", "skills") }]);+ });+});++const harnessClient = async () => {+ const home = await createTestTempDirectory("rea-dsh-");+ const client = supportedClients(home, process.platform, {}).find(+ ({ name }) => name === "dsh",+ );+ if (client?.markerPath === undefined)+ throw new Error("missing DeepSeek Harness client");+ await mkdir(client.markerPath, { recursive: true });+ return { home, client };+};++describe("DeepSeek Harness Cordis patch registration", () => {+ it("appends the rea-mcp insert, preserves user patches, and reads back", async () => {+ const { home, client } = await harnessClient();+ await writeFile(+ client.configPath,+ `# Harness home patch+- insert:+ - id: user-tool+ name: "@deepseek-ai/dsh-mcp-client"+ config:+ serverName: other+ transport: stdio+ command: other-server+`,+ );++ expect(+ (await configureClientConfiguration(client, {}, command)).status,+ ).toBe("configured");+ const text = await readFile(client.configPath, "utf8");+ expect(text).toContain("# Harness home patch");+ expect(parseYaml(text)).toEqual([+ {+ insert: [+ {+ id: "user-tool",+ name: "@deepseek-ai/dsh-mcp-client",+ config: {+ serverName: "other",+ transport: "stdio",+ command: "other-server",+ },+ },+ ],+ },+ {+ insert: [+ {+ id: "rea-mcp",+ name: "@deepseek-ai/dsh-mcp-client",+ config: {+ serverName: "rea",+ transport: "stdio",+ command: command[0],+ args: command.slice(1),+ },+ },+ ],+ },+ ]);++ expect(await configureClientConfiguration(client, {}, command)).toEqual({+ status: "unchanged",+ });+ expect(+ (+ await readClientRegistrationStatuses(home, undefined, {+ platform: process.platform,+ environment: {},+ })+ ).find(({ client: name }) => name === "dsh"),+ ).toMatchObject({ state: "aligned", command });++ expect((await systemUninstallHost(home).removeClient(client)).status).toBe(+ "removed",+ );+ expect(parseYaml(await readFile(client.configPath, "utf8"))).toEqual([+ {+ insert: [+ {+ id: "user-tool",+ name: "@deepseek-ai/dsh-mcp-client",+ config: {+ serverName: "other",+ transport: "stdio",+ command: "other-server",+ },+ },+ ],+ },+ ]);+ });++ it("replaces an existing rea-mcp entry without duplicating it", async () => {+ const { client } = await harnessClient();+ await writeFile(+ client.configPath,+ `- insert:+ - id: rea-mcp+ name: "@deepseek-ai/dsh-mcp-client"+ config:+ serverName: rea+ transport: stdio+ command: stale-launcher+ args: [mcp]+`,+ );++ expect(+ (await configureClientConfiguration(client, {}, command)).status,+ ).toBe("configured");+ const patches = parseYaml(+ await readFile(client.configPath, "utf8"),+ ) as unknown[];+ expect(patches).toHaveLength(1);+ expect((patches[0] as { insert: unknown[] }).insert).toHaveLength(1);+ expect(textOf(await readFile(client.configPath, "utf8"))).not.toContain(+ "stale-launcher",+ );+ });++ it("rewrites a wrong-package rea-mcp entry into the canonical one", async () => {+ const { client } = await harnessClient();+ await writeFile(+ client.configPath,+ `- insert:+ - id: rea-mcp+ name: not-the-harness-client+ config:+ serverName: rea+ transport: stdio+ command: stale-launcher+ args: [mcp]+ env:+ GHIDRA_INSTALL_DIR: /caller/nondefault/ghidra+`,+ );++ // The non-canonical entry reads back as stale, so setup rewrites it with+ // the canonical package name rather than reporting unchanged, and the+ // row's configured environment survives the identity repair.+ expect(+ (await configureClientConfiguration(client, {}, command)).status,+ ).toBe("configured");+ const patches = parseYaml(await readFile(client.configPath, "utf8")) as {+ insert: { id: string; name: string; config?: { env?: unknown } }[];+ }[];+ expect(patches).toHaveLength(1);+ expect(patches[0]?.insert).toHaveLength(1);+ expect(patches[0]?.insert[0]?.id).toBe("rea-mcp");+ expect(patches[0]?.insert[0]?.name).toBe("@deepseek-ai/dsh-mcp-client");+ expect(patches[0]?.insert[0]?.config?.env).toEqual({+ GHIDRA_INSTALL_DIR: "/caller/nondefault/ghidra",+ });+ expect(textOf(await readFile(client.configPath, "utf8"))).not.toContain(+ "not-the-harness-client",+ );+ });+});++describe("DeepSeek Harness registration identity", () => {+ it("applies a direct config patch before judging the registration", async () => {+ const { home, client } = await harnessClient();+ await writeFile(+ client.configPath,+ `- insert:+ - id: rea-mcp+ name: "@deepseek-ai/dsh-mcp-client"+ config:+ serverName: rea+ transport: stdio+ command: ${command[0]}+ args: [${command.slice(1).join(", ")}]+- id: rea-mcp+ config:+ serverName: rea+ transport: stdio+ command: redirected-launcher+ args: [mcp]+`,+ );++ // The later direct patch replaces the row's config, so the effective+ // command is the redirect and the registration is stale, not aligned.+ expect(+ (+ await readClientRegistrationStatuses(home, undefined, {+ platform: process.platform,+ environment: {},+ })+ ).find(({ client: name }) => name === "dsh"),+ ).toMatchObject({ state: "stale" });++ // Setup rewrites one canonical entry and drops the superseded direct op.+ expect(+ (await configureClientConfiguration(client, {}, command)).status,+ ).toBe("configured");+ const text = await readFile(client.configPath, "utf8");+ expect(text).not.toContain("redirected-launcher");+ expect(text).not.toMatch(/^- id: rea-mcp$/mu);+ const patches = parseYaml(text) as unknown[];+ expect(patches).toHaveLength(1);+ });++ it("collapses duplicate rea entries into one canonical row", async () => {+ const { client } = await harnessClient();+ await writeFile(+ client.configPath,+ `- insert:+ - id: rea-mcp+ name: "@deepseek-ai/dsh-mcp-client"+ config:+ serverName: rea+ transport: stdio+ command: first-launcher+ args: [mcp]+- insert:+ - id: rea-mcp+ name: "@deepseek-ai/dsh-mcp-client"+ config:+ serverName: rea+ transport: stdio+ command: second-launcher+ args: [mcp]+`,+ );++ expect(+ (await configureClientConfiguration(client, {}, command)).status,+ ).toBe("configured");+ const patches = parseYaml(await readFile(client.configPath, "utf8")) as {+ insert: unknown[];+ }[];+ const reaRows = patches.flatMap(({ insert }) =>+ insert.filter(+ (entry) =>+ typeof entry === "object" &&+ entry !== null &&+ (entry as { id?: unknown }).id === "rea-mcp",+ ),+ );+ expect(reaRows).toHaveLength(1);+ });++ it("reports a foreign server name as stale instead of aligned", async () => {+ const { home, client } = await harnessClient();+ await writeFile(+ client.configPath,+ `- insert:+ - id: rea-mcp+ name: "@deepseek-ai/dsh-mcp-client"+ config:+ serverName: other+ transport: stdio+ command: ${command[0]}+ args: [${command.slice(1).join(", ")}]+`,+ );++ expect(+ (+ await readClientRegistrationStatuses(home, undefined, {+ platform: process.platform,+ environment: {},+ })+ ).find(({ client: name }) => name === "dsh"),+ ).toMatchObject({ state: "stale" });+ });++ it("creates the patch list for an absent file and empties it on uninstall", async () => {+ const { home, client } = await harnessClient();+ expect(+ (await configureClientConfiguration(client, {}, command)).status,+ ).toBe("configured");+ const created = parseYaml(+ await readFile(client.configPath, "utf8"),+ ) as unknown[];+ expect(created).toEqual([+ {+ insert: [+ {+ id: "rea-mcp",+ name: "@deepseek-ai/dsh-mcp-client",+ config: {+ serverName: "rea",+ transport: "stdio",+ command: command[0],+ args: command.slice(1),+ },+ },+ ],+ },+ ]);+ expect((await systemUninstallHost(home).removeClient(client)).status).toBe(+ "removed",+ );+ expect(await readFile(client.configPath, "utf8")).toBe("[]\n");+ });+});++describe("DeepSeek Harness repair boundaries", () => {+ it("repairs a direct-only registration by appending the insert", async () => {+ const { client } = await harnessClient();+ await writeFile(+ client.configPath,+ `- id: rea-mcp+ name: "@deepseek-ai/dsh-mcp-client"+ config:+ serverName: rea+ transport: stdio+ command: stale-launcher+ args: [mcp]+`,+ );++ // An incomplete manual registration has no insertion to rewrite, so the+ // repair appends one canonical row instead of leaving the entry absent.+ expect(+ (await configureClientConfiguration(client, {}, command)).status,+ ).toBe("configured");+ expect(parseYaml(await readFile(client.configPath, "utf8"))).toEqual([+ {+ insert: [+ {+ id: "rea-mcp",+ name: "@deepseek-ai/dsh-mcp-client",+ config: {+ serverName: "rea",+ transport: "stdio",+ command: command[0],+ args: command.slice(1),+ },+ },+ ],+ },+ ]);+ });++ it("refuses a group-targeted insertion whose applicability is unknown", async () => {+ const { home, client } = await harnessClient();+ const initial = stringifyYaml([+ { id: "missing-group", insert: [canonicalEntry()] },+ ]);+ await writeFile(client.configPath, initial);+ expect(+ (await configureClientConfiguration(client, {}, command)).status,+ ).toBe("failed");+ expect(await dshStatus(home)).not.toMatchObject({ state: "aligned" });+ expect(await readFile(client.configPath, "utf8")).toBe(initial);+ });+});++describe("DeepSeek Harness registration state", () => {+ it("diagnoses a disabled entry as stale and re-enables it on repair", async () => {+ const { home, client } = await harnessClient();+ await writeFile(+ client.configPath,+ `- insert:+ - id: rea-mcp+ name: "@deepseek-ai/dsh-mcp-client"+ disabled: true+ config:+ serverName: rea+ transport: stdio+ command: ${command[0]}+ args: [${command.slice(1).join(", ")}]+`,+ );++ // The command matches, but Cordis never activates a disabled row, so the+ // registration reads as stale rather than aligned.+ expect(+ (+ await readClientRegistrationStatuses(home, undefined, {+ platform: process.platform,+ environment: {},+ })+ ).find(({ client: name }) => name === "dsh"),+ ).toMatchObject({ state: "stale" });++ expect(+ (await configureClientConfiguration(client, {}, command)).status,+ ).toBe("configured");+ const patches = parseYaml(await readFile(client.configPath, "utf8")) as {+ insert: { disabled?: unknown }[];+ }[];+ expect(patches[0]?.insert[0]?.disabled).toBeUndefined();+ expect(+ (await configureClientConfiguration(client, {}, command)).status,+ ).toBe("unchanged");+ });++ it("retains the existing registration environment across a repair", async () => {+ const { client } = await harnessClient();+ await writeFile(+ client.configPath,+ `- insert:+ - id: rea-mcp+ name: "@deepseek-ai/dsh-mcp-client"+ config:+ serverName: rea+ transport: stdio+ command: stale-launcher+ args: [mcp]+ env:+ GHIDRA_INSTALL_DIR: /caller/nondefault/ghidra+`,+ );++ expect(+ (await configureClientConfiguration(client, {}, command)).status,+ ).toBe("configured");+ const patches = parseYaml(await readFile(client.configPath, "utf8")) as {+ insert: { config: { env?: Record<string, string> } }[];+ }[];+ expect(patches[0]?.insert[0]?.config.env).toEqual({+ GHIDRA_INSTALL_DIR: "/caller/nondefault/ghidra",+ });+ });++ it("treats a direct-only registration as absent even when its config matches", async () => {+ const { home, client } = await harnessClient();+ await writeFile(+ client.configPath,+ `- id: rea-mcp+ name: "@deepseek-ai/dsh-mcp-client"+ config:+ serverName: rea+ transport: stdio+ command: ${command[0]}+ args: [${command.slice(1).join(", ")}]+`,+ );++ // A direct patch needs an inserted row to target; with none, Harness has+ // no entry, so the registration is absent rather than aligned.+ expect(+ (+ await readClientRegistrationStatuses(home, undefined, {+ platform: process.platform,+ environment: {},+ })+ ).find(({ client: name }) => name === "dsh"),+ ).toMatchObject({ state: "missing" });++ expect(+ (await configureClientConfiguration(client, {}, command)).status,+ ).toBe("configured");+ const patches = parseYaml(await readFile(client.configPath, "utf8")) as {+ insert: unknown[];+ }[];+ expect(patches).toHaveLength(1);+ expect(patches[0]?.insert).toHaveLength(1);+ });++ it("keeps caller-owned config fields across a refresh", async () => {+ const { client } = await harnessClient();+ const withCwd = (text: string): string =>+ text.replace("args: [mcp]", "args: [mcp]\n cwd: /custom/workdir");+ await writeFile(+ client.configPath,+ withCwd(`- insert:+ - id: rea-mcp+ name: "@deepseek-ai/dsh-mcp-client"+ config:+ serverName: rea+ transport: stdio+ command: stale-launcher+ args: [mcp]+`),+ );++ expect(+ (await configureClientConfiguration(client, {}, command)).status,+ ).toBe("configured");+ const patches = parseYaml(await readFile(client.configPath, "utf8")) as {+ insert: { config: { cwd?: unknown; command?: unknown } }[];+ }[];+ expect(patches[0]?.insert[0]?.config.cwd).toBe("/custom/workdir");+ expect(patches[0]?.insert[0]?.config.command).toBe(command[0]);++ // An otherwise-matching row with caller fields is current, not stale.+ expect(+ (await configureClientConfiguration(client, {}, command)).status,+ ).toBe("unchanged");+ });+});++describe("DeepSeek Harness canonical row repair", () => {+ it("normalizes two aligned insertions instead of reporting unchanged", async () => {+ const { home, client } = await harnessClient();+ const row = `- insert:+ - id: rea-mcp+ name: "@deepseek-ai/dsh-mcp-client"+ config:+ serverName: rea+ transport: stdio+ command: ${command[0]}+ args: [${command.slice(1).join(", ")}]+`;+ await writeFile(client.configPath, `${row}${row}`);++ // Both rows already match, but Cordis still has two insertions. Doctor+ // and setup must normalize to the single owned row.+ const registration = async () =>+ (+ await readClientRegistrationStatuses(home, undefined, {+ platform: process.platform,+ environment: {},+ })+ ).find(({ client: name }) => name === "dsh");+ expect(await registration()).toMatchObject({ state: "stale" });+ expect(+ (await configureClientConfiguration(client, {}, command)).status,+ ).toBe("configured");+ const patches = parseYaml(await readFile(client.configPath, "utf8")) as {+ insert: unknown[];+ }[];+ const reaRows = patches.flatMap(({ insert }) =>+ insert.filter(+ (entry) =>+ typeof entry === "object" &&+ entry !== null &&+ (entry as { id?: unknown }).id === "rea-mcp",+ ),+ );+ expect(reaRows).toHaveLength(1);+ expect(+ (await configureClientConfiguration(client, {}, command)).status,+ ).toBe("unchanged");+ expect(await registration()).toMatchObject({ state: "aligned" });+ });++ it("keeps Cordis expression tags on caller-owned config fields", async () => {+ const { client } = await harnessClient();+ await writeFile(+ client.configPath,+ `- insert:+ - id: rea-mcp+ name: "@deepseek-ai/dsh-mcp-client"+ config:+ serverName: rea+ transport: stdio+ command: stale-launcher+ args: [mcp]+ cwd: !!js process.cwd() # caller launch directory+`,+ );++ expect(+ (await configureClientConfiguration(client, {}, command)).status,+ ).toBe("configured");+ const text = await readFile(client.configPath, "utf8");+ expect(text).toContain("!!js process.cwd()");+ expect(text).toContain("# caller launch directory");+ expect(text).not.toContain("stale-launcher");+ const patches = parseYaml(text, { logLevel: "error" }) as {+ insert: { config: { cwd?: unknown; command?: unknown } }[];+ }[];+ expect(patches[0]?.insert[0]?.config.command).toBe(command[0]);+ expect(patches[0]?.insert[0]?.config.cwd).toBe("process.cwd()");++ expect(+ (await configureClientConfiguration(client, {}, command)).status,+ ).toBe("unchanged");+ expect(await readFile(client.configPath, "utf8")).toContain(+ "!!js process.cwd()",+ );+ });++ it("keeps a Cordis tag from the direct patch that owns the effective config", async () => {+ const { client } = await harnessClient();+ await writeFile(+ client.configPath,+ `- insert:+ - id: rea-mcp+ name: "@deepseek-ai/dsh-mcp-client"+ config:+ serverName: rea+ transport: stdio+ command: first-launcher+ args: [mcp]+- id: rea-mcp+ config:+ serverName: rea+ transport: stdio+ command: stale-launcher+ args: [mcp]+ cwd: !!js process.cwd()+`,+ );++ expect(+ (await configureClientConfiguration(client, {}, command)).status,+ ).toBe("configured");+ const text = await readFile(client.configPath, "utf8");+ expect(text).toContain("!!js process.cwd()");+ expect(text).not.toContain("stale-launcher");+ expect(text).not.toContain("first-launcher");+ expect(text).not.toMatch(/^- id: rea-mcp$/mu);+ const patches = parseYaml(text, { logLevel: "error" }) as {+ insert?: { config?: { cwd?: unknown } }[];+ }[];+ expect(patches).toHaveLength(1);+ expect(patches[0]?.insert?.[0]?.config?.cwd).toBe("process.cwd()");+ });+});++describe("DeepSeek Harness document edges", () => {+ it("keeps Cordis tags on environment values that were not overridden", async () => {+ const { client } = await harnessClient();+ await writeFile(+ client.configPath,+ `- insert:+ - id: rea-mcp+ name: "@deepseek-ai/dsh-mcp-client"+ config:+ serverName: rea+ transport: stdio+ command: stale-launcher+ args: [mcp]+ env:+ OTHER: !!js process.env.OTHER+ TOKEN: !!js process.env.TOKEN # caller token+`,+ );++ expect(+ (await configureClientConfiguration(client, {}, command)).status,+ ).toBe("configured");+ const text = await readFile(client.configPath, "utf8");+ expect(text).toContain("!!js process.env.TOKEN");+ expect(text).toContain("# caller token");+ expect(text).toContain("!!js process.env.OTHER");+ expect(text).not.toContain("stale-launcher");+ const patches = parseYaml(text, { logLevel: "error" }) as {+ insert: { config: { env?: Record<string, string>; command?: string } }[];+ }[];+ expect(patches[0]?.insert[0]?.config.command).toBe(command[0]);+ expect(patches[0]?.insert[0]?.config.env).toEqual({+ OTHER: "process.env.OTHER",+ TOKEN: "process.env.TOKEN",+ });++ expect(+ (await configureClientConfiguration(client, {}, command)).status,+ ).toBe("unchanged");+ expect(await readFile(client.configPath, "utf8")).toContain(+ "!!js process.env.TOKEN",+ );+ });++ it("replaces only the environment entry a caller overrode", async () => {+ const { client } = await harnessClient();+ await writeFile(+ client.configPath,+ `- insert:+ - id: rea-mcp+ name: "@deepseek-ai/dsh-mcp-client"+ config:+ serverName: rea+ transport: stdio+ command: stale-launcher+ args: [mcp]+ env:+ OTHER: !!js process.env.OTHER+ TOKEN: !!js process.env.TOKEN+`,+ );++ expect(+ (+ await configureClientConfiguration(+ client,+ { TOKEN: "literal-override" },+ command,+ )+ ).status,+ ).toBe("configured");+ const text = await readFile(client.configPath, "utf8");+ expect(text).toContain("!!js process.env.OTHER");+ expect(text).not.toContain("!!js process.env.TOKEN");+ expect(text).toContain("literal-override");+ const patches = parseYaml(text, { logLevel: "error" }) as {+ insert: { config: { env?: Record<string, string> } }[];+ }[];+ expect(patches[0]?.insert[0]?.config.env).toEqual({+ OTHER: "process.env.OTHER",+ TOKEN: "literal-override",+ });+ });++ it("appends a registration to a comment-only patch file", async () => {+ const { home, client } = await harnessClient();+ const notes = "# harness notes\n# keep me\n";+ await writeFile(client.configPath, notes);++ expect(+ (+ await readClientRegistrationStatuses(home, undefined, {+ platform: process.platform,+ environment: {},+ })+ ).find(({ client: name }) => name === "dsh"),+ ).toMatchObject({ state: "missing" });+ expect(+ (await configureClientConfiguration(client, {}, command)).status,+ ).toBe("configured");+ const text = await readFile(client.configPath, "utf8");+ expect(text).toContain("# harness notes");+ expect(text).toContain("# keep me");+ expect(text).toContain("id: rea-mcp");+ expect(text).not.toMatch(/^null$/mu);++ expect(+ (await configureClientConfiguration(client, {}, command)).status,+ ).toBe("unchanged");+ expect((await systemUninstallHost(home).removeClient(client)).status).toBe(+ "removed",+ );+ const removed = await readFile(client.configPath, "utf8");+ expect(removed).toContain("# harness notes");+ expect(removed).toContain("# keep me");+ expect(removed).not.toContain("rea-mcp");+ expect(removed).not.toMatch(/^null$/mu);+ });+});++describe("DeepSeek Harness entry ownership", () => {+ const registration = async (home: string) =>+ (+ await readClientRegistrationStatuses(home, undefined, {+ platform: process.platform,+ environment: {},+ })+ ).find(({ client: name }) => name === "dsh");++ it("removes a stale launcher and a direct-only row by entry id", async () => {+ const { home, client } = await harnessClient();+ await writeFile(+ client.configPath,+ `- insert:+ - id: other-tool+ name: other+ config:+ command: keep-me+ - id: rea-mcp+ name: "@deepseek-ai/dsh-mcp-client"+ config:+ serverName: rea+ transport: stdio+ command: stale-launcher+ args: [mcp]+`,+ );++ expect((await systemUninstallHost(home).removeClient(client)).status).toBe(+ "removed",+ );+ const removed = await readFile(client.configPath, "utf8");+ expect(removed).toContain("other-tool");+ expect(removed).not.toContain("rea-mcp");+ expect(removed).not.toContain("stale-launcher");++ await writeFile(+ client.configPath,+ `- id: other-tool+ config:+ command: keep-me+- id: rea-mcp+ name: "@deepseek-ai/dsh-mcp-client"+ config: {}+`,+ );+ expect((await systemUninstallHost(home).removeClient(client)).status).toBe(+ "removed",+ );+ const direct = await readFile(client.configPath, "utf8");+ expect(direct).toContain("other-tool");+ expect(direct).not.toContain("rea-mcp");+ });++ it("treats an expression disabled state as stale and clears it", async () => {+ const { home, client } = await harnessClient();+ await writeFile(+ client.configPath,+ `- insert:+ - id: rea-mcp+ name: "@deepseek-ai/dsh-mcp-client"+ disabled: !!js process.env.DISABLE_REA === "1"+ config:+ serverName: rea+ transport: stdio+ command: ${command[0]}+ args: [${command.slice(1).join(", ")}]+`,+ );++ expect(await registration(home)).toMatchObject({ state: "stale" });+ expect(+ (await configureClientConfiguration(client, {}, command)).status,+ ).toBe("configured");+ const text = await readFile(client.configPath, "utf8");+ expect(text).not.toContain("DISABLE_REA");+ expect(text).not.toContain("disabled:");+ expect(+ (await configureClientConfiguration(client, {}, command)).status,+ ).toBe("unchanged");+ expect(await registration(home)).toMatchObject({ state: "aligned" });+ });++ it("keeps a Cordis expression on a known environment setting", async () => {+ const { home, client } = await harnessClient();+ await writeFile(+ client.configPath,+ `- insert:+ - id: rea-mcp+ name: "@deepseek-ai/dsh-mcp-client"+ config:+ serverName: rea+ transport: stdio+ command: stale-launcher+ args: [mcp]+ env:+ GHIDRA_INSTALL_DIR: !!js process.env.GHIDRA_INSTALL_DIR+`,+ );++ // The expression is not a literal path, so doctor can still classify the+ // row instead of rejecting the file.+ expect(await registration(home)).toMatchObject({ state: "stale" });+ expect(+ (await configureClientConfiguration(client, {}, command)).status,+ ).toBe("configured");+ const text = await readFile(client.configPath, "utf8");+ expect(text).toContain("!!js process.env.GHIDRA_INSTALL_DIR");+ expect(text).not.toContain("stale-launcher");+ const patches = parseYaml(text, { logLevel: "error" }) as {+ insert: { config: { env?: Record<string, string> } }[];+ }[];+ expect(patches[0]?.insert[0]?.config.env).toEqual({+ GHIDRA_INSTALL_DIR: "process.env.GHIDRA_INSTALL_DIR",+ });+ expect(+ (await configureClientConfiguration(client, {}, command)).status,+ ).toBe("unchanged");+ expect(await readFile(client.configPath, "utf8")).toContain(+ "!!js process.env.GHIDRA_INSTALL_DIR",+ );+ });+});++describe("DeepSeek Harness alias collapse", () => {+ it("collapses an aliased insertion and keeps an unrelated alias", async () => {+ const { client } = await harnessClient();+ await writeFile(+ client.configPath,+ `- &other+ insert:+ - id: other-tool+ name: other+ config:+ command: keep-me+- *other+- &row+ insert:+ - id: rea-mcp+ name: "@deepseek-ai/dsh-mcp-client"+ config:+ serverName: rea+ transport: stdio+ command: stale-launcher+ args: [mcp]+- *row+`,+ );++ expect(+ (await configureClientConfiguration(client, {}, command)).status,+ ).toBe("configured");+ const text = await readFile(client.configPath, "utf8");+ expect(text).toContain("*other");+ expect(text).not.toContain("*row");+ expect(text).not.toContain("stale-launcher");+ const patches = parseYaml(text) as { insert?: { id?: string }[] }[];+ const reaRows = patches.flatMap(({ insert }) =>+ (insert ?? []).filter((entry) => entry.id === "rea-mcp"),+ );+ expect(reaRows).toHaveLength(1);+ expect(+ (await configureClientConfiguration(client, {}, command)).status,+ ).toBe("unchanged");+ });++ it("collapses an aliased entry inside one insertion", async () => {+ const { client } = await harnessClient();+ await writeFile(+ client.configPath,+ `- insert:+ - &entry+ id: rea-mcp+ name: "@deepseek-ai/dsh-mcp-client"+ config:+ serverName: rea+ transport: stdio+ command: stale-launcher+ args: [mcp]+ - *entry+`,+ );++ expect(+ (await configureClientConfiguration(client, {}, command)).status,+ ).toBe("configured");+ const text = await readFile(client.configPath, "utf8");+ expect(text).not.toContain("*entry");+ const patches = parseYaml(text) as { insert?: { id?: string }[] }[];+ expect(+ patches.flatMap(({ insert }) =>+ (insert ?? []).filter((entry) => entry.id === "rea-mcp"),+ ),+ ).toHaveLength(1);+ expect(+ (await configureClientConfiguration(client, {}, command)).status,+ ).toBe("unchanged");+ });+});++describe("DeepSeek Harness alias targets", () => {+ it("collapses an alias of the insert list", async () => {+ const { client } = await harnessClient();+ await writeFile(+ client.configPath,+ `- insert: &rows+ - id: other-tool+ name: other+ config:+ command: keep-me+ - id: rea-mcp+ name: "@deepseek-ai/dsh-mcp-client"+ config:+ serverName: rea+ transport: stdio+ command: stale-launcher+ args: [mcp]+- insert: *rows+`,+ );++ expect(+ (await configureClientConfiguration(client, {}, command)).status,+ ).toBe("configured");+ const text = await readFile(client.configPath, "utf8");+ expect(text).toContain("other-tool");+ expect(text).not.toContain("*rows");+ expect(text).not.toContain("stale-launcher");+ const patches = parseYaml(text) as { insert?: { id?: string }[] }[];+ expect(+ patches.flatMap(({ insert }) =>+ (insert ?? []).filter((entry) => entry.id === "rea-mcp"),+ ),+ ).toHaveLength(1);+ expect(+ (await configureClientConfiguration(client, {}, command)).status,+ ).toBe("unchanged");+ });++ it("keeps a Cordis tag when the config map is an alias", async () => {+ const { client } = await harnessClient();+ await writeFile(+ client.configPath,+ `- &cfg+ cwd: !!js process.cwd() # caller launch directory+ serverName: rea+ transport: stdio+ command: stale-launcher+ args: [mcp]+- insert:+ - id: rea-mcp+ name: "@deepseek-ai/dsh-mcp-client"+ config: *cfg+`,+ );++ expect(+ (await configureClientConfiguration(client, {}, command)).status,+ ).toBe("configured");+ const text = await readFile(client.configPath, "utf8");+ expect(text).toContain("!!js process.cwd()");+ expect(text).toContain("# caller launch directory");+ const patches = parseYaml(text, { logLevel: "error" }) as {+ insert?: { config?: { cwd?: unknown; command?: unknown } }[];+ }[];+ const row = patches.find((patch) => patch.insert !== undefined);+ expect(row?.insert?.[0]?.config?.cwd).toBe("process.cwd()");+ expect(row?.insert?.[0]?.config?.command).toBe(command[0]);+ expect(+ (await configureClientConfiguration(client, {}, command)).status,+ ).toBe("unchanged");+ });+});++describe("DeepSeek Harness alias identity", () => {+ it("keeps unrelated rows when the insert list is anchored outside an operation", async () => {+ const { client } = await harnessClient();+ await writeFile(+ client.configPath,+ `- &rows+ - id: other-tool+ name: other+ config:+ command: keep-me+ - id: rea-mcp+ name: "@deepseek-ai/dsh-mcp-client"+ config:+ serverName: rea+ transport: stdio+ command: stale-launcher+ args: [mcp]+- insert: *rows+`,+ );++ expect(+ (await configureClientConfiguration(client, {}, command)).status,+ ).toBe("configured");+ const patches = parseYaml(await readFile(client.configPath, "utf8")) as {+ insert?: { id?: string; config?: { command?: string } }[];+ }[];+ const inserted = patches.flatMap((patch) => patch.insert ?? []);+ expect(inserted.filter((entry) => entry.id === "other-tool")).toHaveLength(+ 1,+ );+ expect(inserted.filter((entry) => entry.id === "rea-mcp")).toEqual([+ expect.objectContaining({+ config: expect.objectContaining({ command: command[0] }),+ }),+ ]);+ expect(+ (await configureClientConfiguration(client, {}, command)).status,+ ).toBe("unchanged");+ });++ it("keeps an aliased Cordis tag on an environment value", async () => {+ const { client } = await harnessClient();+ await writeFile(+ client.configPath,+ `- &expr !!js process.env.TOKEN+- insert:+ - id: rea-mcp+ name: "@deepseek-ai/dsh-mcp-client"+ config:+ serverName: rea+ transport: stdio+ command: stale-launcher+ args: [mcp]+ env:+ TOKEN: *expr+`,+ );++ expect(+ (await configureClientConfiguration(client, {}, command)).status,+ ).toBe("configured");+ const text = await readFile(client.configPath, "utf8");+ expect(text).toContain("!!js process.env.TOKEN");+ expect(text).toContain("*expr");+ expect(text).not.toContain("stale-launcher");+ expect(+ (await configureClientConfiguration(client, {}, command)).status,+ ).toBe("unchanged");+ });++ it("recognizes an aliased entry id", async () => {+ const { home, client } = await harnessClient();+ await writeFile(+ client.configPath,+ `- &entryId rea-mcp+- insert:+ - id: *entryId+ name: "@deepseek-ai/dsh-mcp-client"+ config:+ serverName: rea+ transport: stdio+ command: stale-launcher+ args: [mcp]+`,+ );++ expect(+ (await configureClientConfiguration(client, {}, command)).status,+ ).toBe("configured");+ const patches = parseYaml(await readFile(client.configPath, "utf8")) as {+ insert?: { id?: string }[];+ }[];+ expect(+ patches.flatMap((patch) =>+ (patch.insert ?? []).filter((entry) => entry.id === "rea-mcp"),+ ),+ ).toHaveLength(1);+ expect((await systemUninstallHost(home).removeClient(client)).status).toBe(+ "removed",+ );+ expect(await readFile(client.configPath, "utf8")).not.toContain("*entryId");+ });+});++describe("DeepSeek Harness alias cleanup", () => {+ it("keeps tags when the environment map is an alias", async () => {+ const { client } = await harnessClient();+ await writeFile(+ client.configPath,+ `- &reaEnv+ TOKEN: !!js process.env.TOKEN+- insert:+ - id: rea-mcp+ name: "@deepseek-ai/dsh-mcp-client"+ config:+ serverName: rea+ transport: stdio+ command: stale-launcher+ args: [mcp]+ env: *reaEnv+`,+ );++ expect(+ (await configureClientConfiguration(client, {}, command)).status,+ ).toBe("configured");+ const text = await readFile(client.configPath, "utf8");+ expect(text).toContain("!!js process.env.TOKEN");+ expect(text).not.toContain("stale-launcher");+ expect(+ (await configureClientConfiguration(client, {}, command)).status,+ ).toBe("unchanged");+ });++ it("does not validate an aliased Cordis path expression as a literal", async () => {+ const { home, client } = await harnessClient();+ await writeFile(+ client.configPath,+ `- &expr !!js process.env.GHIDRA_INSTALL_DIR+- insert:+ - id: rea-mcp+ name: "@deepseek-ai/dsh-mcp-client"+ config:+ serverName: rea+ transport: stdio+ command: stale-launcher+ args: [mcp]+ env:+ GHIDRA_INSTALL_DIR: *expr+`,+ );++ expect(+ (+ await readClientRegistrationStatuses(home, undefined, {+ platform: process.platform,+ environment: {},+ })+ ).find(({ client: name }) => name === "dsh"),+ ).toMatchObject({ state: "stale" });+ expect(+ (await configureClientConfiguration(client, {}, command)).status,+ ).toBe("configured");+ expect(await readFile(client.configPath, "utf8")).toContain(+ "!!js process.env.GHIDRA_INSTALL_DIR",+ );+ });++ it("removes an aliased insert list on uninstall", async () => {+ const { home, client } = await harnessClient();+ await writeFile(+ client.configPath,+ `- insert: &rows+ - id: rea-mcp+ name: "@deepseek-ai/dsh-mcp-client"+ config:+ serverName: rea+ transport: stdio+ command: ${command[0]}+ args: [${command.slice(1).join(", ")}]+- insert: *rows+`,+ );++ expect((await systemUninstallHost(home).removeClient(client)).status).toBe(+ "removed",+ );+ const text = await readFile(client.configPath, "utf8");+ expect(text).not.toContain("rea-mcp");+ expect(text).not.toContain("*rows");+ });+});++describe("DeepSeek Harness root aliases", () => {+ it("uses a direct patch replayed by a root alias as the winning config", async () => {+ const { home, client } = await harnessClient();+ await writeFile(+ client.configPath,+ `- insert:+ - id: rea-mcp+ name: "@deepseek-ai/dsh-mcp-client"+ config:+ serverName: rea+ transport: stdio+ command: first-launcher+ args: [mcp]+ env:+ GHIDRA_INSTALL_DIR: /absolute/ghidra+- &patch+ id: rea-mcp+ config:+ serverName: rea+ transport: stdio+ command: stale-launcher+ args: [mcp]+ env:+ GHIDRA_INSTALL_DIR: !!js process.env.GHIDRA_INSTALL_DIR+- *patch+`,+ );++ expect(+ (+ await readClientRegistrationStatuses(home, undefined, {+ platform: process.platform,+ environment: {},+ })+ ).find(({ client: name }) => name === "dsh"),+ ).toMatchObject({ state: "stale" });+ expect(+ (await configureClientConfiguration(client, {}, command)).status,+ ).toBe("configured");+ expect(await readFile(client.configPath, "utf8")).toContain(+ "!!js process.env.GHIDRA_INSTALL_DIR",+ );+ });++ it("removes a root alias of the owned insertion on uninstall", async () => {+ const { home, client } = await harnessClient();+ await writeFile(+ client.configPath,+ `- &row+ insert:+ - id: rea-mcp+ name: "@deepseek-ai/dsh-mcp-client"+ config:+ serverName: rea+ transport: stdio+ command: ${command[0]}+ args: [${command.slice(1).join(", ")}]+- *row+`,+ );++ expect((await systemUninstallHost(home).removeClient(client)).status).toBe(+ "removed",+ );+ const text = await readFile(client.configPath, "utf8");+ expect(text).not.toContain("rea-mcp");+ expect(text).not.toContain("*row");+ });++ it("keeps a Cordis tag when the only owned row is an alias", async () => {+ const { client } = await harnessClient();+ await writeFile(+ client.configPath,+ `- &entry+ id: rea-mcp+ name: "@deepseek-ai/dsh-mcp-client"+ config:+ serverName: rea+ transport: stdio+ command: stale-launcher+ args: [mcp]+ cwd: !!js process.cwd()+- insert:+ - *entry+`,+ );++ expect(+ (await configureClientConfiguration(client, {}, command)).status,+ ).toBe("configured");+ const text = await readFile(client.configPath, "utf8");+ expect(text).toContain("!!js process.cwd()");+ expect(text).not.toContain("stale-launcher");+ const patches = parseYaml(text, { logLevel: "error" }) as {+ insert?: { config?: { cwd?: unknown; command?: unknown } }[];+ }[];+ const row = patches.find((patch) => patch.insert !== undefined);+ expect(row?.insert?.[0]?.config?.cwd).toBe("process.cwd()");+ expect(row?.insert?.[0]?.config?.command).toBe(command[0]);+ });+});++const loadedInserts = (+ text: string,+): { id?: string; config?: { command?: string } }[] => {+ const patches = parseYaml(text) as {+ insert?: { id?: string; config?: { command?: string } }[];+ }[];+ return patches.flatMap((patch) => patch.insert ?? []);+};++describe("DeepSeek Harness inert anchors", () => {+ it("keeps unrelated rows when the only active insertion is a root alias", async () => {+ const { client } = await harnessClient();+ await writeFile(+ client.configPath,+ `- holder: &op+ insert:+ - id: other-tool+ name: other+ config:+ command: keep-me+ - id: rea-mcp+ name: "@deepseek-ai/dsh-mcp-client"+ config:+ serverName: rea+ transport: stdio+ command: stale-launcher+ args: [mcp]+- *op+`,+ );++ expect(+ (await configureClientConfiguration(client, {}, command)).status,+ ).toBe("configured");+ const inserted = loadedInserts(await readFile(client.configPath, "utf8"));+ expect(inserted.filter((entry) => entry.id === "other-tool")).toHaveLength(+ 1,+ );+ expect(inserted.filter((entry) => entry.id === "rea-mcp")).toEqual([+ expect.objectContaining({+ config: expect.objectContaining({ command: command[0] }),+ }),+ ]);+ expect(+ (await configureClientConfiguration(client, {}, command)).status,+ ).toBe("unchanged");+ });++ it("keeps unrelated rows when uninstall removes that root alias", async () => {+ const { home, client } = await harnessClient();+ await writeFile(+ client.configPath,+ `- holder: &op+ insert:+ - id: other-tool+ name: other+ config:+ command: keep-me+ - id: rea-mcp+ name: "@deepseek-ai/dsh-mcp-client"+ config:+ serverName: rea+ transport: stdio+ command: ${command[0]}+ args: [${command.slice(1).join(", ")}]+- *op+`,+ );++ expect((await systemUninstallHost(home).removeClient(client)).status).toBe(+ "removed",+ );+ const text = await readFile(client.configPath, "utf8");+ expect(parseYaml(text)).toBeTruthy();+ const inserted = loadedInserts(text);+ expect(inserted.filter((entry) => entry.id === "other-tool")).toHaveLength(+ 1,+ );+ expect(inserted.filter((entry) => entry.id === "rea-mcp")).toHaveLength(0);+ });+});++describe("DeepSeek Harness alias anchors", () => {+ it("rewrites an entry id alias before removing its anchor", async () => {+ const { client } = await harnessClient();+ await writeFile(+ client.configPath,+ `- id: &entryId rea-mcp+ config:+ serverName: rea+ transport: stdio+ command: stale-launcher+ args: [mcp]+- insert:+ - id: *entryId+ name: "@deepseek-ai/dsh-mcp-client"+ config:+ serverName: rea+ transport: stdio+ command: stale-launcher+ args: [mcp]+`,+ );++ expect(+ (await configureClientConfiguration(client, {}, command)).status,+ ).toBe("configured");+ const text = await readFile(client.configPath, "utf8");+ expect(text).not.toContain("*entryId");+ expect(+ loadedInserts(text).filter((entry) => entry.id === "rea-mcp"),+ ).toHaveLength(1);+ expect(+ (await configureClientConfiguration(client, {}, command)).status,+ ).toBe("unchanged");+ });++ it("edits a root alias whose insert list is itself an alias", async () => {+ const { client } = await harnessClient();+ await writeFile(+ client.configPath,+ `- &rows+ - id: other-tool+ name: other+ config:+ command: keep-me+ - id: rea-mcp+ name: "@deepseek-ai/dsh-mcp-client"+ config:+ serverName: rea+ transport: stdio+ command: stale-launcher+ args: [mcp]+- holder: &op+ insert: *rows+- *op+`,+ );++ expect(+ (await configureClientConfiguration(client, {}, command)).status,+ ).toBe("configured");+ const inserted = loadedInserts(await readFile(client.configPath, "utf8"));+ expect(inserted.filter((entry) => entry.id === "other-tool")).toHaveLength(+ 1,+ );+ expect(inserted.filter((entry) => entry.id === "rea-mcp")).toHaveLength(1);+ expect(+ (await configureClientConfiguration(client, {}, command)).status,+ ).toBe("unchanged");+ });++ it("drops a replayed root alias after its insert alias is emptied", async () => {+ const { home, client } = await harnessClient();+ await writeFile(+ client.configPath,+ `- &rows+ - id: rea-mcp+ name: "@deepseek-ai/dsh-mcp-client"+ config:+ serverName: rea+ transport: stdio+ command: ${command[0]}+ args: [${command.slice(1).join(", ")}]+- &op+ insert: *rows+- *op+`,+ );++ expect((await systemUninstallHost(home).removeClient(client)).status).toBe(+ "removed",+ );+ const text = await readFile(client.configPath, "utf8");+ expect(text).not.toContain("*op");+ expect(() => parseYaml(text)).not.toThrow();+ });+});++const textOf = (value: unknown): string => String(value);++/** Same tagged expression representation as Harness's entry-list schema. */+const cordisPatches = (text: string) =>+ parseYaml(text, {+ customTags: [+ {+ tag: "tag:yaml.org,2002:js",+ resolve: (source: string) => ({ __jsExpr: source }),+ },+ ],+ }) as { insert?: { id?: string; config?: Record<string, unknown> }[] }[];++const canonicalEntry = () => ({+ id: "rea-mcp",+ name: "@deepseek-ai/dsh-mcp-client",+ config: {+ serverName: "rea",+ transport: "stdio",+ command: command[0],+ args: command.slice(1),+ },+});++const dshStatus = async (home: string) =>+ (+ await readClientRegistrationStatuses(home, undefined, {+ platform: process.platform,+ environment: {},+ })+ ).find(({ client }) => client === "dsh");++describe("DeepSeek Harness source ownership", () => {+ it.each(["setup", "uninstall"])(+ "preserves unrelated rows in a later externally anchored operation during %s",+ async (operation) => {+ const { home, client } = await harnessClient();+ const initial = `${stringifyYaml([{ insert: [canonicalEntry()] }])}- holder: &op+ insert:+ - id: other-tool+ name: other+ config: {command: keep-me}+ - id: rea-mcp+ name: '@deepseek-ai/dsh-mcp-client'+ config: {serverName: rea, transport: stdio, command: stale, args: [mcp]}+- *op+`;+ await writeFile(client.configPath, initial);+ const result =+ operation === "setup"+ ? await configureClientConfiguration(client, {}, command)+ : await systemUninstallHost(home).removeClient(client);+ expect(result.status).toBe(+ operation === "setup" ? "configured" : "removed",+ );+ const entries = loadedInserts(await readFile(client.configPath, "utf8"));+ expect(entries.filter(({ id }) => id === "other-tool")).toEqual([+ { id: "other-tool", name: "other", config: { command: "keep-me" } },+ ]);+ expect(entries.filter(({ id }) => id === "rea-mcp")).toHaveLength(+ operation === "setup" ? 1 : 0,+ );+ expect(await readFile(`${client.configPath}.rea.backup`, "utf8")).toBe(+ initial,+ );+ },+ );++ it.each(["inline", "aliased config"])(+ "snapshots environment aliases before replacing their anchor in %s",+ async (shape) => {+ const { client } = await harnessClient();+ const config = `serverName: rea+ transport: stdio+ command: stale-launcher+ args: [mcp]+ env:+ A: &expr !!js process.env.TOKEN # caller expression+ B: *expr+`;+ const initial =+ shape === "inline"+ ? `- insert:\n - id: rea-mcp\n name: '@deepseek-ai/dsh-mcp-client'\n config:\n ${config.replaceAll("\n", "\n ").trimEnd()}\n`+ : `- holder: &cfg\n ${config}- insert:\n - id: rea-mcp\n name: '@deepseek-ai/dsh-mcp-client'\n config: *cfg\n`;+ await writeFile(client.configPath, initial);+ expect(+ (+ await configureClientConfiguration(+ client,+ { A: "literal-override" },+ command,+ )+ ).status,+ ).toBe("configured");+ const text = await readFile(client.configPath, "utf8");+ const row = cordisPatches(text)+ .flatMap((op) => op.insert ?? [])+ .find(({ id }) => id === "rea-mcp");+ expect(row?.config?.env).toEqual({+ A: "literal-override",+ B: { __jsExpr: "process.env.TOKEN" },+ });+ expect(text).toContain("# caller expression");+ expect(+ (+ await configureClientConfiguration(+ client,+ { A: "literal-override" },+ command,+ )+ ).status,+ ).toBe("unchanged");+ },+ );++ it("keeps expression aliases used by unrelated rows when removing their source entry", async () => {+ const { home, client } = await harnessClient();+ const initial = `- insert:+ - id: rea-mcp+ name: '@deepseek-ai/dsh-mcp-client'+ config:+ command: stale+ cwd: &cwd !!js process.cwd()+ - id: other-tool+ name: other+ config:+ cwd: *cwd+`;+ await writeFile(client.configPath, initial);+ expect((await systemUninstallHost(home).removeClient(client)).status).toBe(+ "removed",+ );+ expect(cordisPatches(await readFile(client.configPath, "utf8"))).toEqual([+ {+ insert: [+ {+ id: "other-tool",+ name: "other",+ config: { cwd: { __jsExpr: "process.cwd()" } },+ },+ ],+ },+ ]);+ });+});++describe("DeepSeek Harness registration applicability", () => {+ it("preserves literal scalar keys in unrelated and caller-owned config", async () => {+ const { client } = await harnessClient();+ const initial = `- insert:+ - id: other+ name: caller-plugin+ config: {1: one, true: yes}+ - id: rea-mcp+ name: '@deepseek-ai/dsh-mcp-client'+ config: {command: stale, extra: {2: two}}+`;+ await writeFile(client.configPath, initial);+ expect(+ (await configureClientConfiguration(client, {}, command)).status,+ ).toBe("configured");+ const rows = cordisPatches(await readFile(client.configPath, "utf8"))[0]+ ?.insert;+ expect(rows?.[0]?.config).toEqual({ "1": "one", true: "yes" });+ expect(rows?.[1]?.config?.extra).toEqual({ "2": "two" });+ expect(+ (await configureClientConfiguration(client, {}, command)).status,+ ).toBe("unchanged");+ });++ it("uses direct-patch names as selectors and preserves the actual effective config", async () => {+ const { home, client } = await harnessClient();+ const entry = canonicalEntry();+ const initial = stringifyYaml([+ {+ insert: [+ {+ ...entry,+ name: "other-package",+ config: { ...entry.config, env: { FROM_INSERT: "keep-me" } },+ },+ ],+ },+ {+ id: "rea-mcp",+ name: entry.name,+ config: { ...entry.config, env: { FROM_SKIPPED_PATCH: "discard-me" } },+ },+ ]);+ await writeFile(client.configPath, initial);+ expect(await dshStatus(home)).toMatchObject({ state: "stale" });+ expect(+ (await configureClientConfiguration(client, {}, command)).status,+ ).toBe("configured");+ expect(+ cordisPatches(await readFile(client.configPath, "utf8"))[0]?.insert?.[0]+ ?.config?.env,+ ).toEqual({ FROM_INSERT: "keep-me" });+ expect(await dshStatus(home)).toMatchObject({ state: "aligned" });+ });++ it.each(["serverName", "transport", "command", "args"] as const)(+ "distinguishes expression-backed %s from literal launcher values",+ async (key) => {+ const { home, client } = await harnessClient();+ const entry = canonicalEntry();+ const doc = stringifyYaml([{ insert: [entry] }]);+ const { parseDocument } = await import("yaml");+ const yaml = parseDocument(doc);+ const expression = yaml.createNode(+ key === "args" ? "[]" : String(entry.config[key]),+ );+ expression.tag = "tag:yaml.org,2002:js";+ yaml.setIn([0, "insert", 0, "config", key], expression);+ await writeFile(client.configPath, yaml.toString());+ expect((await dshStatus(home))?.state).not.toBe("aligned");+ expect(+ (await configureClientConfiguration(client, {}, command)).status,+ ).toBe("configured");+ expect(cordisPatches(await readFile(client.configPath, "utf8"))).toEqual([+ { insert: [entry] },+ ]);+ expect(await dshStatus(home)).toMatchObject({ state: "aligned" });+ },+ );++ it("keeps caller config separate from package, duplicate and activation diagnostics", async () => {+ const { home, client } = await harnessClient();+ const entry = canonicalEntry();+ const initial = stringifyYaml([+ {+ insert: [+ {+ ...entry,+ config: {+ ...entry.config,+ package: "caller-package",+ duplicate: "caller-state",+ disabled: "caller-value",+ enabled: false,+ },+ },+ ],+ },+ ]);+ await writeFile(client.configPath, initial);+ expect(+ (await configureClientConfiguration(client, {}, command)).status,+ ).toBe("unchanged");+ expect(await dshStatus(home)).toMatchObject({ state: "aligned" });+ expect(await readFile(client.configPath, "utf8")).toBe(initial);+ });++ it.each([+ "- &cycle {holder: *cycle}\n",+ "- insert: [\n",+ "- insert: *missing\n",+ [+ "- holder: &a [value, value]",+ "- holder: &b [*a, *a, *a, *a, *a, *a, *a, *a, *a, *a]",+ "- holder: &c [*b, *b, *b, *b, *b, *b, *b, *b, *b, *b]",+ "- insert: [{id: rea-mcp, config: {extra: *c}}]",+ ].join("\n"),+ "- insert: [{id: rea-mcp, name: '@deepseek-ai/dsh-mcp-client', config: !!js process.env.CONFIG}]\n",+ ])("refuses unsafe YAML without mutation: %s", async (initial) => {+ const { client } = await harnessClient();+ await writeFile(client.configPath, initial);+ expect(+ (await configureClientConfiguration(client, {}, command)).status,+ ).toBe("failed");+ expect(await readFile(client.configPath, "utf8")).toBe(initial);+ await expect(+ readFile(`${client.configPath}.rea.backup`),+ ).rejects.toMatchObject({+ code: "ENOENT",+ });+ });+});++describe("DeepSeek Harness ownership and editability", () => {+ it.each([+ `- insert: [{id: !!js '"rea-mcp"', name: caller-plugin}]\n`,+ `- id: !!js '"rea-mcp"'\n config: {command: caller-launcher}\n`,+ `- holder: &id !!js '"rea-mcp"'\n- insert: [{id: *id}]\n`,+ ])("retains registrations with unknown ID ownership: %s", async (initial) => {+ const { home, client } = await harnessClient();+ await writeFile(client.configPath, initial);+ expect(await dshStatus(home)).toMatchObject({ state: "invalid" });+ expect(+ (await configureClientConfiguration(client, {}, command)).status,+ ).toBe("failed");+ const host = systemUninstallHost(home);+ expect(await host.inspectClient(client)).toMatchObject({+ status: "failed",+ });+ expect((await host.removeClient(client)).status).toBe("failed");+ expect(await readFile(client.configPath, "utf8")).toBe(initial);+ await expect(+ readFile(`${client.configPath}.rea.backup`),+ ).rejects.toMatchObject({+ code: "ENOENT",+ });+ });++ it.each(["selector", "insertion"] as const)(+ "preserves unknown %s name applicability while allowing owned removal",+ async (expressionPosition) => {+ const { home, client } = await harnessClient();+ const { parseDocument } = await import("yaml");+ const yaml = parseDocument(+ stringifyYaml([+ { insert: [canonicalEntry()] },+ {+ id: "rea-mcp",+ name: "@deepseek-ai/dsh-mcp-client",+ config: { command: "patched-launcher" },+ },+ ]),+ );+ const expression = yaml.createNode('"@deepseek-ai/dsh-mcp-client"');+ expression.tag = "tag:yaml.org,2002:js";+ yaml.setIn(+ expressionPosition === "selector"+ ? [1, "name"]+ : [0, "insert", 0, "name"],+ expression,+ );+ const initial = yaml.toString();+ await writeFile(client.configPath, initial);+ expect(await dshStatus(home)).toMatchObject({ state: "invalid" });+ expect(+ (await configureClientConfiguration(client, {}, command)).status,+ ).toBe("failed");+ expect(await readFile(client.configPath, "utf8")).toBe(initial);+ const host = systemUninstallHost(home);+ expect(await host.inspectClient(client)).toBeUndefined();+ expect((await host.removeClient(client)).status).toBe("removed");+ expect(parseYaml(await readFile(client.configPath, "utf8"))).toEqual([]);+ expect(await readFile(`${client.configPath}.rea.backup`, "utf8")).toBe(+ initial,+ );+ },+ );+});++describe("DeepSeek Harness aliased mapping keys", () => {+ it.each(["setup", "uninstall"])(+ "resolves owned fields and preserves caller config during %s",+ async (operation) => {+ const { home, client } = await harnessClient();+ const initial = `- holder: &insertKey insert+- holder: &idKey id+- holder: &configKey config+- holder: &envKey env+- ? *insertKey+ : - ? *idKey+ : rea-mcp+ name: '@deepseek-ai/dsh-mcp-client'+ ? *configKey+ : command: stale+ ? *envKey+ : TOKEN: keep-me+ - id: other+ name: caller-plugin+`;+ await writeFile(client.configPath, initial);+ const result =+ operation === "setup"+ ? await configureClientConfiguration(client, {}, command)+ : await systemUninstallHost(home).removeClient(client);+ expect(result.status).toBe(+ operation === "setup" ? "configured" : "removed",+ );+ const entries = loadedInserts(await readFile(client.configPath, "utf8"));+ expect(entries.filter(({ id }) => id === "other")).toEqual([+ { id: "other", name: "caller-plugin" },+ ]);+ const owned = entries.filter(({ id }) => id === "rea-mcp");+ expect(owned).toHaveLength(operation === "setup" ? 1 : 0);+ if (operation === "setup") {+ expect(owned[0]?.config).toMatchObject({ env: { TOKEN: "keep-me" } });+ expect(await dshStatus(home)).toMatchObject({ state: "aligned" });+ expect(+ (await configureClientConfiguration(client, {}, command)).status,+ ).toBe("unchanged");+ }+ expect(await readFile(`${client.configPath}.rea.backup`, "utf8")).toBe(+ initial,+ );+ },+ );+});++describe("DeepSeek Harness ordered selector applicability", () => {+ it.each(["before insertion", "before replacement"])(+ "discards selector uncertainty %s",+ async (position) => {+ const { home, client } = await harnessClient();+ const selector = `- id: rea-mcp+ name: !!js '"@deepseek-ai/dsh-mcp-client"'+ config: {command: ignored-launcher, env: {IGNORED: discarded}}+`;+ const insertion = stringifyYaml([{ insert: [canonicalEntry()] }]);+ const initial =+ position === "before insertion"+ ? selector + insertion+ : insertion + selector + insertion;+ await writeFile(client.configPath, initial);+ expect((await dshStatus(home))?.state).toBe(+ position === "before insertion" ? "aligned" : "stale",+ );+ expect(+ (await configureClientConfiguration(client, {}, command)).status,+ ).toBe(position === "before insertion" ? "unchanged" : "configured");+ expect(await dshStatus(home)).toMatchObject({ state: "aligned" });+ const text = await readFile(client.configPath, "utf8");+ expect(+ cordisPatches(text)+ .flatMap((patch) => patch.insert ?? [])+ .filter(({ id }) => id === "rea-mcp"),+ ).toEqual([canonicalEntry()]);+ if (position === "before insertion") expect(text).toBe(initial);+ expect(+ (await systemUninstallHost(home).removeClient(client)).status,+ ).toBe("removed");+ expect(loadedInserts(await readFile(client.configPath, "utf8"))).toEqual(+ [],+ );+ },+ );+});++describe("DeepSeek Harness caller node metadata", () => {+ it.each(["environment", "launcher"])(+ "preserves scalar and argument comments during %s repairs",+ async (repair) => {+ const { home, client } = await harnessClient();+ const entry = canonicalEntry();+ const yaml = parseDocument(+ stringifyYaml([+ {+ insert: [+ {+ ...entry,+ config: {+ ...entry.config,+ ...(repair === "launcher" ? { command: "stale" } : {}),+ env: { TOKEN: "original" },+ },+ },+ ],+ },+ ]),+ );+ for (const path of [+ [0, "insert", 0, "id"],+ [0, "insert", 0, "name"],+ ...["serverName", "transport", "command", "args"].map((key) => [+ 0,+ "insert",+ 0,+ "config",+ key,+ ]),+ [0, "insert", 0, "config", "env", "TOKEN"],+ ]) {+ const node = yaml.getIn(path, true);+ if (!isNode(node)) throw new Error("missing caller node");+ node.comment = ` caller ${path.at(-1)}`;+ node.commentBefore = ` before ${path.at(-1)}`;+ }+ const args = yaml.getIn([0, "insert", 0, "config", "args"], true);+ if (!isSeq(args) || !isNode(args.items[0]))+ throw new Error("missing launcher arguments");+ args.items[0].comment = " caller argument";+ const initial = yaml.toString();+ await writeFile(client.configPath, initial);+ expect(+ (+ await configureClientConfiguration(+ client,+ { TOKEN: "updated" },+ command,+ )+ ).status,+ ).toBe("configured");+ const text = await readFile(client.configPath, "utf8");+ for (const key of [+ "id",+ "name",+ "serverName",+ "transport",+ "command",+ "args",+ "TOKEN",+ ]) {+ expect(text).toContain(`# caller ${key}`);+ expect(text).toContain(`# before ${key}`);+ }+ expect(text).toContain("# caller argument");+ expect(loadedInserts(text)).toEqual([+ {+ ...entry,+ config: { ...entry.config, env: { TOKEN: "updated" } },+ },+ ]);+ expect(await dshStatus(home)).toMatchObject({ state: "aligned" });+ expect(+ (+ await configureClientConfiguration(+ client,+ { TOKEN: "updated" },+ command,+ )+ ).status,+ ).toBe("unchanged");+ expect(await readFile(client.configPath, "utf8")).toBe(text);+ expect(await readFile(`${client.configPath}.rea.backup`, "utf8")).toBe(+ initial,+ );+ },+ );+});diff --git a/tests/fixtures/clientEnvironment.ts b/tests/fixtures/clientEnvironment.tsindex 91ccb92cf..35fc6843c 100644--- a/tests/fixtures/clientEnvironment.ts+++ b/tests/fixtures/clientEnvironment.ts@@ -15,6 +15,8 @@ export const CLIENT_LOCATION_ENVIRONMENT = ["APPDATA","CLAUDE_CONFIG_DIR","CODEX_HOME",+ "DSH_HOME",+ "DSH_AGENTS_HOME","COPILOT_HOME","GROK_HOME","GEMINI_CLI_HOME",