@dsh-electron/dsh-plugin-multi-root-workspace 0.1.6 → 0.1.8

package/lib/compat-B6ZqbQBy.js

@@ -1,295 +0,0 @@
-import { createRequire } from "node:module";
-import { Service } from "@deepseek-ai/cordis";
-//#region src/compat/dsh-version.ts
-/**
-* The DSH compatibility contract: which upstream releases this plugin is
-* actually verified against, and how an installation is judged against that
-* list.
-*
-* This module is the ONE place the support matrix is spelled out. It is
-* deliberately pure — no cordis, no logging, no process exit — so that the
-* runtime gate (`src/compat.ts`), the static gate (`scripts/check-dsh-compat.mjs`)
-* and the tests all judge an installation by the same code instead of three
-* drifting copies of the same list.
-*
-* Why a contract exists at all: this plugin replaces `ctx.fs` and `ctx.sandbox`
-* with subclasses of the upstream providers, and `src/dialects.ts` recognizes
-* the kernel-sandbox profile by OBSERVING the argv shape `super.confine`
-* produced (ADR-0003). Both couplings are to pre-stable upstream internals that
-* carry no semver promise. An npm range like `>=0.1.2-alpha.4 <0.2.0` therefore
-* promises far more than the code was ever verified against; the allowlist
-* below promises exactly what CI has run.
-*
-* @module @dsh-electron/dsh-plugin-multi-root-workspace/compat/dsh-version
-*/
-/**
-* The releases this plugin is verified against, as EXACT version strings.
-*
-* Not a semver range, on purpose: a range is a prediction about releases that
-* do not exist yet, and this plugin's coupling to upstream argv shapes makes
-* that prediction unsafe. Adding an entry is always a human act performed after
-* the upgrade smoke passed on that exact version — a green CI run on an
-* unlisted release is evidence, not authorization (ADR-0009).
-*/
-const SUPPORTED_DSH_RELEASES = [
-	"0.1.5-rc.2",
-	"0.1.6-alpha.1",
-	"0.1.6-alpha.2",
-	"0.1.7-alpha.1",
-	"0.1.7-alpha.2",
-	"0.1.7-rc.1",
-	"0.1.7-rc.2",
-	"0.2.0-rc.1",
-	"0.2.0-rc.2",
-	"0.2.1-alpha.1",
-	"0.2.1-alpha.2"
-];
-/**
-* Packages whose absence means this plugin cannot function at all: every one of
-* them is either subclassed, imported for a value, or the owner of a service
-* key the providers inject.
-*/
-const REQUIRED_CORE_PACKAGES = [
-	"@deepseek-ai/dsh-fs",
-	"@deepseek-ai/dsh-fs-local",
-	"@deepseek-ai/dsh-sandbox",
-	"@deepseek-ai/dsh-sandbox-local",
-	"@deepseek-ai/dsh-sandbox-policy",
-	"@deepseek-ai/dsh-storage-domain"
-];
-/**
-* Packages a full composition provides and a minimal one legitimately omits.
-* Absence is fine; a version that DISAGREES with the required packages is not —
-* that is the mixed-installation failure this contract exists to catch.
-*/
-const OPTIONAL_CORE_PACKAGES = [
-	"@deepseek-ai/dsh-tools",
-	"@deepseek-ai/dsh-working-directory",
-	"@deepseek-ai/dsh-lsp",
-	"@deepseek-ai/dsh-lsp-stdio",
-	"@deepseek-ai/dsh-api-workspace-files",
-	"@deepseek-ai/dsh-typert-protocol",
-	"@deepseek-ai/dsh-sandbox-windows-acl",
-	"@deepseek-ai/dsh-agent",
-	"@deepseek-ai/dsh-agent-instructions",
-	"@deepseek-ai/dsh-client-connection",
-	"@deepseek-ai/dsh-commands",
-	"@deepseek-ai/dsh-llm",
-	"@deepseek-ai/dsh-session",
-	"@deepseek-ai/dsh-subprocess",
-	"@deepseek-ai/dsh-system-prompt"
-];
-/** 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";
-/**
-* 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.
-* @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;
-		}
-	}
-}
-/**
-* Judge one installation against the contract.
-*
-* The three checks run in this order, and the first failure wins, because each
-* later check would report nonsense about an installation that failed an
-* earlier one: a missing required package has no version to compare, and a
-* mixed installation has no single version to look up in the allowlist.
-* @param readVersion - version reader; defaults to Node resolution. Tests and
-*   the static checker pass their own.
-* @returns the report; never throws.
-*/
-function classifyInstallation(readVersion = readInstalledVersion) {
-	const packages = CORE_PACKAGES.map((name) => ({
-		name,
-		version: readVersion(name),
-		required: REQUIRED_CORE_PACKAGES.includes(name)
-	}));
-	const missing = packages.filter((entry) => entry.required && entry.version === void 0);
-	if (missing.length > 0) return report("incomplete", void 0, packages, [
-		"multi-root workspace: required DSH packages are not installed.",
-		"",
-		...missing.map((entry) => `  missing: ${entry.name}`)
-	]);
-	const releases = [...new Set(packages.flatMap((entry) => entry.version === void 0 ? [] : [entry.version]))].sort();
-	const [release, ...extra] = releases;
-	if (release === void 0) return report("incomplete", void 0, packages, ["multi-root workspace: no DSH package could be inspected."]);
-	if (extra.length > 0) return report("mixed", void 0, packages, [
-		"multi-root workspace: this installation mixes several DSH releases.",
-		"",
-		"The filesystem fence and the kernel-sandbox dialects must agree on one upstream",
-		"release; a mixed installation means one half of the sandbox was verified against a",
-		"shape the other half no longer produces. Align every @deepseek-ai/dsh* package on",
-		"one release.",
-		"",
-		`  releases found: ${releases.join(", ")}`
-	]);
-	if (!SUPPORTED_DSH_RELEASES.includes(release)) return report("unsupported", release, packages, [
-		`multi-root workspace: DSH ${release} is not a supported release.`,
-		"",
-		"This plugin replaces the workspace filesystem fence and the kernel-sandbox provider,",
-		"and it recognizes the sandbox profile by the argv shape the upstream provider produces.",
-		"Upstream makes no semver promise, so the plugin refuses to grant additional roots on a",
-		"release it has never been verified against rather than guess at that shape.",
-		"",
-		`  supported: ${SUPPORTED_DSH_RELEASES.join(", ")}`,
-		`  installed: ${release}`
-	]);
-	return report("supported", release, packages, [`multi-root workspace: DSH ${release} is a supported release.`]);
-}
-/**
-* Read the enforcement mode.
-*
-* `warn` exists for exactly one caller: the upgrade smoke, which must run the
-* whole behavior matrix against a release that is deliberately NOT on the
-* allowlist yet — that run is how a release earns its place on the list. It is
-* not a production escape hatch, and the warning says so.
-* @param env - the environment to read; defaults to this process's.
-* @returns `warn` only when explicitly requested, `enforce` otherwise.
-*/
-function compatEnforcement(env = process.env) {
-	return env["DSH_MULTI_ROOT_COMPAT"] === "warn" ? "warn" : "enforce";
-}
-/** Compose a report, appending the package inventory and the recovery pointer. */
-function report(verdict, release, packages, lines) {
-	return {
-		verdict,
-		release,
-		packages,
-		message: (verdict === "supported" ? [...lines] : [
-			...lines,
-			"",
-			"Inspected packages:",
-			...packages.map((entry) => `  ${entry.name} ${entry.version ?? "(not installed)"}`),
-			"",
-			"See docs/troubleshooting/unsupported-dsh-release.md"
-		]).join("\n")
-	};
-}
-//#endregion
-//#region src/compat.ts
-/**
-* `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:
-*
-* ```text
-* compat check passes  →  ctx.multiRootCompat exists  →  the providers start
-* compat check fails   →  the row throws             →  they never start
-* ```
-*
-* 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
-* already claimed the service key — by the time it could inspect anything.
-*
-* The verdict itself, and the allowlist it is judged against, live in
-* `./compat/dsh-version.ts`. This module owns only the reaction to it.
-*
-* @module @dsh-electron/dsh-plugin-multi-root-workspace/compat
-*/
-/**
-* Raised when the installed DSH release is not one this plugin is verified
-* against. It is thrown from `apply`, so it surfaces as a plugin load failure
-* with the full diagnosis attached — never as a silently degraded sandbox.
-*/
-var DshCompatUnsupportedError = class extends Error {
-	/** The report that produced the refusal. */
-	report;
-	constructor(report) {
-		super(report.message);
-		this.name = "DshCompatUnsupportedError";
-		this.report = report;
-	}
-};
-/**
-* The `ctx.multiRootCompat` service: the resolved compatibility verdict, held
-* where the gated providers can read it.
-*
-* It intentionally exposes no per-version capability flags. The adapters under
-* `./compat/` detect the shape they need STRUCTURALLY — whether a return value
-* is a thenable, which export name a module carries — because a structural
-* probe also survives upstream reshaping something within one release, while a
-* version comparison does not. The release string here is for the gate and for
-* diagnostics.
-*/
-var MultiRootCompatService = class extends Service {
-	/** The verdict this composition started under. */
-	report;
-	constructor(ctx, report) {
-		super(ctx, "multiRootCompat");
-		this.report = report;
-	}
-	/** The single DSH release every inspected core package agreed on. */
-	get release() {
-		return this.report.release;
-	}
-	/** Whether the installation is on the allowlist. */
-	get supported() {
-		return this.report.verdict === "supported";
-	}
-};
-/** This row needs nothing: it is the thing everything else waits for. */
-const inject = [];
-/**
-* Apply the gate policy to one report.
-*
-* Under `DSH_MULTI_ROOT_COMPAT=warn` exactly one verdict is relaxed: an
-* `unsupported` release that every inspected package agrees on. That is the
-* only shape the upgrade smoke probes — a coherent tree on a release the
-* allowlist does not name yet, which is how a release earns its place there.
-* `mixed` and `incomplete` describe an installation the contract cannot judge
-* at all, so they are refused in either mode; production deployments leave the
-* variable unset and get the refusal for everything.
-* @param report - the verdict to act on.
-* @param enforcement - how to react to a non-`supported` verdict.
-* @returns the warning to log, or `undefined` when there is nothing to say.
-* @throws {DshCompatUnsupportedError} when refusing to run.
-*/
-function assertSupportedInstallation(report, enforcement) {
-	if (report.verdict === "supported") return void 0;
-	if (enforcement === "enforce" || report.verdict !== "unsupported") throw new DshCompatUnsupportedError(report);
-	return `${report.message}\n\nProceeding anyway because ${COMPAT_ENFORCEMENT_ENV}=warn. This is an upgrade-smoke mode: additional workspace roots are about to be granted through a sandbox profile shape that has not been verified on this release. Supported releases: ${SUPPORTED_DSH_RELEASES.join(", ")}.`;
-}
-/**
-* Judge the installation, then either refuse to provide the service or provide
-* it.
-* @param ctx - the row's context.
-*/
-function apply(ctx) {
-	const report = classifyInstallation();
-	const warning = assertSupportedInstallation(report, compatEnforcement());
-	if (warning !== void 0) ctx.logger.warn(warning);
-	ctx.plugin(MultiRootCompatService, report);
-}
-//#endregion
-export { inject as a, REQUIRED_CORE_PACKAGES as c, compatEnforcement as d, readInstalledVersion as f, assertSupportedInstallation as i, SUPPORTED_DSH_RELEASES as l, MultiRootCompatService as n, CORE_PACKAGES as o, apply as r, OPTIONAL_CORE_PACKAGES as s, DshCompatUnsupportedError as t, classifyInstallation as u };

package/lib/method-wrapper-Zc-JlDP3.js

@@ -1,51 +0,0 @@
-import { canonicalPath } from "@deepseek-ai/dsh-sandbox";
-//#region src/workspace-routing.ts
-/** Resolve relative paths against the primary cwd; never search other roots by basename. */
-async function routeWorkspacePath(ctx, primaryRoot, path, signal, cwd = primaryRoot) {
-	signal?.throwIfAborted();
-	const primary = canonicalPath(primaryRoot);
-	const roots = [primary, ...ctx.multiRootScope.scopeOf(primary)];
-	const target = await ctx.fs.resolve(path, {
-		cwd,
-		...signal === void 0 ? {} : { signal }
-	});
-	for (const root of roots) {
-		const rootTarget = await ctx.fs.resolve(root, signal === void 0 ? {} : { signal });
-		if (!ctx.fs.contains(rootTarget, target)) continue;
-		if (root !== primary && !ctx.multiRootScope.scopeOf(primary).includes(root)) return void 0;
-		signal?.throwIfAborted();
-		return {
-			primaryRoot: primary,
-			workspaceRoot: root,
-			target,
-			absolutePath: ctx.fs.processPath(target)
-		};
-	}
-}
-//#endregion
-//#region src/method-wrapper.ts
-/** Wrap a public method on a Cordis service without capturing a caller-context proxy. */
-function wrapMethod(target, key, wrap) {
-	const own = Object.getOwnPropertyDescriptor(target, key);
-	let prototype = target;
-	let descriptor;
-	while (prototype !== null && descriptor === void 0) {
-		descriptor = Object.getOwnPropertyDescriptor(prototype, key);
-		prototype = Object.getPrototypeOf(prototype);
-	}
-	if (typeof descriptor?.value !== "function") throw new Error(`multi-root: ${String(key)} is not a public method`);
-	const value = wrap(descriptor.value);
-	Object.defineProperty(target, key, {
-		configurable: true,
-		writable: true,
-		enumerable: own?.enumerable ?? false,
-		value
-	});
-	return () => {
-		if (Object.getOwnPropertyDescriptor(target, key)?.value !== value) return;
-		if (own === void 0) Reflect.deleteProperty(target, key);
-		else Object.defineProperty(target, key, own);
-	};
-}
-//#endregion
-export { routeWorkspacePath as n, wrapMethod as t };

package/lib/sandbox-BRXl_FpF.js

@@ -1,132 +0,0 @@
-import { a as splitConfined, i as DialectUnrecognizedError, n as widenWindowsProfile, o as widenProfileArgs } from "./windows-profile-CiFsFYIV.js";
-import { SandboxUnavailableError } from "@deepseek-ai/dsh-sandbox";
-import { LocalSandboxProvider } from "@deepseek-ai/dsh-sandbox-local";
-//#region src/compat/sandbox-confine.ts
-/** Whether a value is a thenable, i.e. whether the installed `confine` is async. */
-function isThenable(value) {
-	return typeof value?.then === "function";
-}
-/**
-* Call the upstream `confine` and widen its result, preserving sync/async shape.
-*
-* @param base - the upstream `confine`, already bound to its provider.
-* @param widen - the pure transformation to apply to the upstream result. It
-*   runs exactly once per call, on whichever release; it may throw, and the
-*   throw surfaces synchronously or as a rejection to match the base shape.
-* @param argv - the caller's argv, forwarded verbatim.
-* @param policy - the per-call policy, forwarded verbatim.
-* @param signal - forwarded when the installed release accepts it.
-* @returns the widened result, in the shape the installed release uses.
-*/
-function widenConfined(base, widen, argv, policy, signal) {
-	const confined = base(argv, policy, signal);
-	return isThenable(confined) ? confined.then(widen) : widen(confined);
-}
-//#endregion
-//#region src/sandbox.ts
-/**
-* `MultiRootSandboxProvider`: the kernel-sandbox dialect provider mounted as
-* `ctx.sandbox`.
-*
-* Every confined execution in this composition funnels through `confine()` —
-* the bash executor wraps `['bash','-c',command]`, and the terminal backend
-* wraps its PTY spawn argv — so widening the grant here is what gives bash, PTY,
-* and the fs fence one and the same root set (requirement §13). The bash
-* executor itself is therefore left upstream: it never computes roots.
-*
-* POSIX widening lives in `./dialects.ts`, Windows capabilities in
-* `./windows-profile.ts` and `./windows-runner.ts`: the upstream profile builders
-* are unreachable in the published package, so the additional roots are grafted
-* onto the profile `super.confine` actually produced (recognize the dialect
-* structurally, clone its grant spelling, fail loudly when the shape is not
-* known). This class owns only the policy that decides WHEN to graft:
-*
-* 1. with no additional roots, or under any mode other than `workspace-write`,
-*    the upstream result is returned ELEMENT FOR ELEMENT — same argv, same
-*    `enforcement`, same `denialSignatures`, same `runnerFailureRules`;
-* 2. `enforcement`, `denialSignatures`, and `runnerFailureRules` are NEVER
-*    recomputed here, even when the argv is widened — the bash executor derives
-*    its denial and enforcement reporting from them;
-* 3. only `argv` may differ, and a dialect whose shape cannot be extended fails
-*    loudly (`SandboxUnavailableError`) instead of silently confining to the
-*    primary root alone.
-*
-* @module @dsh-electron/dsh-plugin-multi-root-workspace/sandbox
-*/
-/**
-* Local process-sandbox provider over the multi-root scope. Registers as
-* `ctx.sandbox`; the runner chain, probing, denial dialects, and Windows ACL
-* grant mechanics stay the upstream implementation's.
-*/
-var MultiRootSandboxProvider = class extends LocalSandboxProvider {
-	static inject = [
-		"multiRootCompat",
-		"sandboxPolicy",
-		"multiRootScope"
-	];
-	/**
-	* Wrap `argv` so it executes confined under `policy` on this host, granting
-	* the scope's additional roots inside the SAME dialect profile.
-	*
-	* Under `read-only` nothing is added (the mode denies every write, additional
-	* roots included), and `danger-full-access` never reaches here at all: the
-	* bash executor and the PTY backend both hand their argv straight to the local
-	* runtime in that mode. Widening therefore only ever ADDS the scope's
-	* additional roots to an upstream `workspace-write` profile.
-	*
-	* The return shape is the INSTALLED upstream provider's: synchronous on a
-	* release with a synchronous `confine`, a promise on a release with an
-	* asynchronous one. `widenConfined` preserves whichever it is — see
-	* `./compat/sandbox-confine.ts`.
-	* @param argv - the exact argv the caller is about to spawn.
-	* @param policy - the file-effect policy this execution runs under.
-	* @param signal - cancellation, forwarded to releases that accept it.
-	* @returns the argv to spawn instead, plus the selected backend's facts.
-	*/
-	confine(argv, policy, signal) {
-		const base = super.confine;
-		return widenConfined(base.bind(this), (confined) => this.widenForScope(confined, argv, policy), argv, policy, signal);
-	}
-	/**
-	* Graft the scope's additional roots onto one upstream `confine` result.
-	*
-	* Pure with respect to the upstream call: it only ever reads the scope and
-	* rewrites `argv`. `enforcement`, `denialSignatures` and `runnerFailureRules`
-	* are passed through untouched, because the bash executor derives its denial
-	* and enforcement reporting from them.
-	* @param confined - the upstream result for this call.
-	* @param argv - the caller's argv, needed to re-split the wrapped form.
-	* @param policy - the per-call policy.
-	* @returns the upstream result element for element, or one with a widened argv.
-	*/
-	widenForScope(confined, argv, policy) {
-		if (policy.mode !== "workspace-write") return confined;
-		const scope = this.ctx.multiRootScope.resolve(policy);
-		if (scope.additionalRoots.length === 0) return confined;
-		try {
-			const shape = splitConfined(confined.argv, argv);
-			if (shape.dialect === "windows-acl") return {
-				...confined,
-				argv: [
-					...widenWindowsProfile(shape.profileArgs, scope.additionalRoots, scope.primaryRoot),
-					"--",
-					...argv
-				]
-			};
-			const profileArgs = widenProfileArgs(shape.dialect, shape.profileArgs, policy, scope.additionalRoots);
-			return {
-				...confined,
-				argv: [
-					...profileArgs,
-					"--",
-					...argv
-				]
-			};
-		} catch (error) {
-			if (!(error instanceof DialectUnrecognizedError)) throw error;
-			throw new SandboxUnavailableError(policy.mode, `multi-root workspace: cannot grant the additional workspace roots [${scope.additionalRoots.join(", ")}] under the primary root ${scope.primaryRoot} — ${error.message}`);
-		}
-	}
-};
-//#endregion
-export { widenConfined as n, MultiRootSandboxProvider as t };

package/lib/types/client/RootFileTree.d.ts

@@ -1,12 +0,0 @@
-/** Lazy additional-root tree and bounded text previews; requests carry a session and exact root. */
-import { type ReactNode } from 'react';
-import type { RootEntryView } from '../contract.ts';
-import type { PanelClient } from './panel-client.ts';
-import type { Translate } from './WorkspaceFoldersAction.tsx';
-export interface RootFileTreeProps {
-    panel: PanelClient;
-    entry: RootEntryView;
-    sessionId: () => string | undefined;
-    t: Translate;
-}
-export declare function RootFileTree(props: RootFileTreeProps): ReactNode;

package/lib/types/panel-files.d.ts

@@ -1,3 +0,0 @@
-import type { Context } from '@deepseek-ai/cordis';
-import type { PanelCall, FilePreview, FilesView } from './contract.ts';
-export declare function browseRoot(ctx: Context, primaryRoot: string, request: PanelCall, signal: AbortSignal): Promise<FilesView | FilePreview>;