@dsh-electron/dsh-plugin-multi-root-workspace 0.1.7 → 0.1.9

package/lib/{compat-DF_yL1bB.js → compat-CagUNzRB.js}

@@ -1,7 +1,8 @@
 import { createRequire } from "node:module";
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { dirname, join, sep } from "node:path";
 import { Service } from "@deepseek-ai/cordis";
-import { readFileSync, readdirSync } from "node:fs";
-import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
 //#region src/compat/dsh-version.ts
 /**
 * The DSH compatibility contract: which upstream releases this plugin is
@@ -86,39 +87,175 @@ const OPTIONAL_CORE_PACKAGES = [
 	"@deepseek-ai/dsh-subprocess",
 	"@deepseek-ai/dsh-system-prompt"
 ];
+/**
+* The optional packages this plugin loads itself at run time, through dynamic
+* `import()`s inside this package's own modules. The copy this module resolves
+* IS the copy that would execute, so every resolvable hit testifies — a
+* private copy inside this package's own tree genuinely loads, and a version
+* that disagrees with the host is a real mixed installation, not a phantom.
+*/
+const RUNTIME_OPTIONAL_PACKAGES = [
+	"@deepseek-ai/dsh-agent-instructions",
+	"@deepseek-ai/dsh-llm",
+	"@deepseek-ai/dsh-session",
+	"@deepseek-ai/dsh-typert-protocol"
+];
+/**
+* The optional packages this plugin consumes only as mounted host services or
+* ambient types — it never imports them, so a copy inside this package's own
+* tree can never execute. The only version that testifies is the one the
+* COMPOSITION resolves (the installation or the profile): a resolution that
+* lands inside this package's own root is a private development or bundled
+* copy and must be reported absent — otherwise a `link:`-installed checkout
+* whose devDependencies carry a newer release phantom-mixes every supported
+* host it is developed against (the report that motivated this split:
+* `dsh-lsp`/`dsh-lsp-stdio`/`dsh-working-directory` resolving to the plugin's
+* devDependencies on a `0.2.0-rc.2` host produced a `mixed` verdict on a
+* uniformly `0.2.0-rc.2` installation).
+*/
+const HOST_SERVICE_PACKAGES = [
+	"@deepseek-ai/dsh-agent",
+	"@deepseek-ai/dsh-api-workspace-files",
+	"@deepseek-ai/dsh-client-connection",
+	"@deepseek-ai/dsh-commands",
+	"@deepseek-ai/dsh-lsp",
+	"@deepseek-ai/dsh-lsp-stdio",
+	"@deepseek-ai/dsh-subprocess",
+	"@deepseek-ai/dsh-system-prompt",
+	"@deepseek-ai/dsh-tools",
+	"@deepseek-ai/dsh-working-directory"
+];
+/**
+* Optional packages this plugin executes that are resolved through an anchor
+* OTHER than this module. The standalone Windows ACL runner
+* (`src/windows-runner.ts`) imports `@deepseek-ai/dsh-sandbox-windows-acl` by
+* self-reference from the upstream runner's own install location — a file the
+* installed `dsh-sandbox-local` points at in its confined argv — so the copy
+* that testifies is the one sibling to that required package, not whatever
+* this module can reach. Neither the self-resolution hit nor the
+* `@deepseek-ai/dsh` host anchor reflects execution here: if sandbox-local's
+* own anchor cannot see the package, the runner cannot load it either, and
+* absent is the honest answer.
+*/
+const RUNNER_ANCHORED_PACKAGES = ["@deepseek-ai/dsh-sandbox-windows-acl"];
+/** The required package whose tree produces the upstream runner argv. */
+const RUNNER_ANCHOR_PACKAGE = "@deepseek-ai/dsh-sandbox-local";
 /** Every package the contract inspects, required first. */
 const CORE_PACKAGES = [...REQUIRED_CORE_PACKAGES, ...OPTIONAL_CORE_PACKAGES];
-/** Services looked up structurally; older runtimes never install these modules. */
-const HOST_RESOLVED_PACKAGES = ["@deepseek-ai/dsh-working-directory"];
 /** The environment variable that relaxes the gate. */
 const COMPAT_ENFORCEMENT_ENV = "DSH_MULTI_ROOT_COMPAT";
 /**
+* Resolve one package's `package.json` path through a require, or `undefined`
+* when it cannot be resolved. The path — not just the version — matters: the
+* caller needs to know WHERE the copy lives to judge whether it belongs to the
+* inspected installation.
+* @param require - the require to resolve through.
+* @param packageName - the package to locate.
+* @returns the manifest path, or `undefined`.
+*/
+function resolvePackageJson(require, packageName) {
+	try {
+		return require.resolve(`${packageName}/package.json`);
+	} catch {
+		return;
+	}
+}
+/** Read `version` off a resolved manifest path; a broken manifest is absent. */
+function versionOfManifest(manifestPath) {
+	try {
+		const manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
+		return typeof manifest.version === "string" ? manifest.version : void 0;
+	} catch {
+		return;
+	}
+}
+/**
+* The second resolution anchor: a require rooted at the installed
+* `@deepseek-ai/dsh` meta package. Host-internal packages that never appear as
+* plugin peers are only reachable this way (the pattern the retired
+* `HOST_RESOLVED_PACKAGES` list carved out for `dsh-working-directory`,
+* generalized here to every host-service package).
+* @param require - this module's require, used to locate the meta package.
+* @returns the host-rooted require, or `undefined` when `dsh` itself cannot be
+*   resolved.
+*/
+function hostAnchorRequire(require) {
+	const anchor = resolvePackageJson(require, "@deepseek-ai/dsh");
+	return anchor === void 0 ? void 0 : createRequire(anchor);
+}
+/**
+* This package's own install root — the boundary between a copy that belongs
+* to the inspected installation and a private copy only this package can see.
+* @param require - this module's require; self-reference through the package's
+*   `exports` is tried first, then a walk up from this module's file.
+* @returns the package root, or `undefined` when neither anchor works.
+*/
+function pluginPackageRoot(require) {
+	try {
+		return dirname(require.resolve("@dsh-electron/dsh-plugin-multi-root-workspace/package.json"));
+	} catch {
+		let dir = dirname(fileURLToPath(import.meta.url));
+		while (true) {
+			if (existsSync(join(dir, "package.json"))) return dir;
+			const parent = dirname(dir);
+			if (parent === dir) return void 0;
+			dir = parent;
+		}
+	}
+}
+/**
+* Whether a resolved manifest path lives inside this package's own root — the
+* mark of a private copy no composition can mount. An unknown root cannot
+* exclude anything, so it answers `false` rather than guessing.
+*/
+function insidePackageRoot(manifestPath, root) {
+	return root !== void 0 && (manifestPath === root || manifestPath.startsWith(`${root}${sep}`));
+}
+/**
 * Read one package's declared version through Node resolution.
 *
-* Resolution runs from THIS module, which is what makes the answer meaningful:
-* the upstream packages are peer dependencies, so they resolve to the single
-* copy the host provides — the same copy the providers will subclass at
-* runtime. A package that cannot be resolved is reported absent rather than
-* throwing, because "not installed" is a legitimate answer for every optional
-* package.
+* Resolution runs from THIS module — for required and runtime-loaded packages
+* the copy found here is the copy that would execute, which is what makes the
+* answer meaningful: the upstream packages are peer dependencies, so they
+* resolve to the single copy the host provides — the same copy the providers
+* will subclass at runtime.
+*
+* {@link HOST_SERVICE_PACKAGES} are different: the plugin never imports them,
+* so a copy inside this package's own tree can never execute, and counting it
+* would report a mixed installation out of a linked checkout's devDependencies
+* alone. Only a hit OUTSIDE this package's root — a copy the composition could
+* mount — testifies; when this module cannot reach the package at all, the
+* `@deepseek-ai/dsh` host manifest supplies a second anchor for host-internal
+* packages that are never plugin peers.
+*
+* {@link RUNNER_ANCHORED_PACKAGES} are a third policy: executed, but resolved
+* from the upstream-runner anchor rather than this module, so only a hit
+* sibling to the installed `dsh-sandbox-local` testifies.
+*
+* A package that cannot be resolved in either place is reported absent rather
+* than throwing, because "not installed" is a legitimate answer for every
+* optional package.
 * @param packageName - the package to inspect.
 * @returns the declared version, or `undefined` when the package or its
 *   manifest cannot be resolved.
 */
 function readInstalledVersion(packageName) {
 	const require = createRequire(import.meta.url);
-	try {
-		const manifest = require(`${packageName}/package.json`);
-		return typeof manifest.version === "string" ? manifest.version : void 0;
-	} catch {
-		if (!HOST_RESOLVED_PACKAGES.includes(packageName)) return void 0;
-		try {
-			const manifest = createRequire(require.resolve("@deepseek-ai/dsh/package.json"))(`${packageName}/package.json`);
-			return typeof manifest.version === "string" ? manifest.version : void 0;
-		} catch {
-			return;
-		}
+	if (RUNNER_ANCHORED_PACKAGES.includes(packageName)) {
+		const anchor = resolvePackageJson(require, RUNNER_ANCHOR_PACKAGE);
+		const hit = anchor === void 0 ? void 0 : resolvePackageJson(createRequire(anchor), packageName);
+		return hit === void 0 ? void 0 : versionOfManifest(hit);
+	}
+	if (!HOST_SERVICE_PACKAGES.includes(packageName)) {
+		const hit = resolvePackageJson(require, packageName);
+		return hit === void 0 ? void 0 : versionOfManifest(hit);
 	}
+	const root = pluginPackageRoot(require);
+	const selfHit = resolvePackageJson(require, packageName);
+	if (selfHit !== void 0 && !insidePackageRoot(selfHit, root)) return versionOfManifest(selfHit);
+	const host = hostAnchorRequire(require);
+	const hostHit = host === void 0 ? void 0 : resolvePackageJson(host, packageName);
+	return hostHit === void 0 || insidePackageRoot(hostHit, root) ? void 0 : versionOfManifest(hostHit);
 }
 /**
 * Judge one installation against the contract.
@@ -223,7 +360,7 @@ function report(verdict, release, packages, lines) {
 * Resolution follows the optional-peer precedent (`agent-instructions.ts`):
 * the backend is not a peer of this plugin, so the plugin anchor is tried
 * first (flat layouts) and the `@deepseek-ai/dsh` host anchor second — the
-* same `HOST_RESOLVED_PACKAGES` pattern as `dsh-version.ts` — because the
+* same host-anchor fallback pattern as `dsh-version.ts` — because the
 * backend rides inside the harness meta package's own dependency tree.
 *
 * @module @dsh-electron/dsh-plugin-multi-root-workspace/compat/pty-marker
@@ -256,7 +393,7 @@ var PtyMarkerContractError = class extends Error {
 * reach: this module first (flat layouts where the backend is a direct
 * install), then the `@deepseek-ai/dsh` host manifest (pnpm-style layouts
 * where it is the meta package's own dependency — the
-* `HOST_RESOLVED_PACKAGES` precedent). A resolution failure that is not a
+* host-anchor fallback pattern in `dsh-version.ts`). A resolution failure that is not a
 * genuine NOT_FOUND propagates: a resolvable-but-broken specifier is not
 * evidence of absence.
 */
@@ -354,16 +491,26 @@ function assertAgentPtyMarker(io = defaultIo) {
 * `multi-root-compat`: the startup gate that turns the DSH compatibility
 * contract from documentation into a precondition.
 *
-* The four security-relevant rows of this bundle — `multi-root-fs`,
-* `multi-root-sandbox`, `multi-root-registry`, `multi-root-instructions` —
-* inject `multiRootCompat`. Cordis will not start a plugin whose injected
-* service is absent, so this row is what decides whether they run at all:
+* Every widened-authority row of this bundle — `multi-root-providers`,
+* `multi-root-registry`, `multi-root-instructions`, `multi-root-lsp`,
+* `multi-root-workspace-files`, `multi-root-process-fence` — injects
+* `multiRootCompat`. Cordis will not start a plugin whose injected service is
+* absent, so this row is what decides whether they run at all:
 *
 * ```text
-* compat check passes  →  ctx.multiRootCompat exists  →  the providers start
+* compat check passes  →  ctx.multiRootCompat exists  →  the gated rows start
 * compat check fails   →  the row throws             →  they never start
 * ```
 *
+* The two PROVIDER rows (`multi-root-fs`, `multi-root-sandbox`) deliberately
+* do NOT inject the gate: their widening is scope-driven, and the gated
+* registry can never populate the scope on a refused installation — so they
+* degenerate to the upstream providers. That is what keeps a refused gate a
+* loud degradation (the plugin's features absent, the profile intact) instead
+* of a dead profile: upstream `fs-sandbox`/`sandbox` are already disabled by
+* the patch, so holding `ctx.fs`/`ctx.sandbox` back would take `ctx.shell`,
+* `permissionPresets` and every confining tool down with them.
+*
 * That is why the gate is a plain `apply` and not a `Service` subclass mounted
 * directly: the check has to be able to fail BEFORE the service exists. A
 * `Service` constructor has already run `super(ctx, name)` — and therefore
@@ -450,4 +597,4 @@ function apply(ctx) {
 	ctx.plugin(MultiRootCompatService, report);
 }
 //#endregion
-export { inject as a, agentPtyMarkerVerdict as c, OPTIONAL_CORE_PACKAGES as d, REQUIRED_CORE_PACKAGES as f, readInstalledVersion as g, compatEnforcement as h, assertSupportedInstallation as i, assertAgentPtyMarker as l, classifyInstallation as m, MultiRootCompatService as n, AGENT_PTY_MARKER as o, SUPPORTED_DSH_RELEASES as p, apply as r, PtyMarkerContractError as s, DshCompatUnsupportedError as t, CORE_PACKAGES as u };
+export { classifyInstallation as _, inject as a, agentPtyMarkerVerdict as c, HOST_SERVICE_PACKAGES as d, OPTIONAL_CORE_PACKAGES as f, SUPPORTED_DSH_RELEASES as g, RUNTIME_OPTIONAL_PACKAGES as h, assertSupportedInstallation as i, assertAgentPtyMarker as l, RUNNER_ANCHORED_PACKAGES as m, MultiRootCompatService as n, AGENT_PTY_MARKER as o, REQUIRED_CORE_PACKAGES as p, apply as r, PtyMarkerContractError as s, DshCompatUnsupportedError as t, CORE_PACKAGES as u, compatEnforcement as v, readInstalledVersion as y };

package/lib/compat.js

@@ -1,2 +1,2 @@
-import { a as inject, i as assertSupportedInstallation, n as MultiRootCompatService, r as apply, t as DshCompatUnsupportedError } from "./compat-DF_yL1bB.js";
+import { a as inject, i as assertSupportedInstallation, n as MultiRootCompatService, r as apply, t as DshCompatUnsupportedError } from "./compat-CagUNzRB.js";
 export { DshCompatUnsupportedError, MultiRootCompatService, apply, assertSupportedInstallation, inject };