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

package/lib/{roots-DasWEBJk.js → roots-B-0l8mNG.js}

@@ -1,6 +1,7 @@
+import { i as isWindowsNetworkOrDevicePath } from "./windows-runner-contract-CEfmZzu0.js";
+import { statSync } from "node:fs";
 import { isAbsolute, join, sep } from "node:path";
 import { canonicalPath } from "@deepseek-ai/dsh-sandbox";
-import { statSync } from "node:fs";
 import { homedir } from "node:os";
 //#region src/roots.ts
 /**
@@ -27,10 +28,18 @@ import { homedir } from "node:os";
 * 6. `duplicate` — another registered root canonicalizes to the same path.
 * 7. `nested` — the candidate lies under a registered root, or contains one.
 *    Same reasoning as rule 5, applied to the additional roots.
+* 8. `unsupported-path` — on Windows, a network or device path (`\\server`,
+*    `\\?\…`, `\\.\…`): the ACL confinement cannot be shown to cover it, so it
+*    is rejected lexically before any filesystem touch.
 *
 * The stored side of the same rules lives in {@link classifyStoredRoots}, which
 * must never throw: a registration that stopped being usable is REPORTED, not
-* deleted, so the operator can see it and remove it deliberately.
+* deleted, so the operator can see it and remove it deliberately. It runs in
+* two passes — every record's own structural trust and availability first,
+* then overlap between the RECORDED boundaries of all structurally sound
+* records — so the answer never depends on registry order, and a pair of
+* records whose grants collide (`membership-conflict`) keeps its trustworthy
+* negative boundary even while its membership is withheld.
 *
 * @module @dsh-electron/dsh-plugin-multi-root-workspace/roots
 */
@@ -117,7 +126,10 @@ function validateRootCandidate(raw, context) {
 	const expanded = expandRootInput(raw, context.home);
 	if (expanded === "") throw new RootValidationError("not-absolute", "a root path is required");
 	if (!isAbsolute(expanded)) throw new RootValidationError("not-absolute", `"${expanded}" is not an absolute path; give an absolute directory or one starting with "~/"`, { reference: expanded });
+	const platform = context.platform ?? process.platform;
+	if (platform === "win32" && isWindowsNetworkOrDevicePath(expanded)) throw unsupportedPath(expanded);
 	const canonical = canonicalRoot(expanded);
+	if (platform === "win32" && isWindowsNetworkOrDevicePath(canonical)) throw unsupportedPath(expanded);
 	assertDirectory(canonical, expanded);
 	const primaryRoot = canonicalRoot(context.primaryRoot);
 	if (samePath(canonical, primaryRoot)) throw new RootValidationError("equals-primary", `"${canonical}" is this session's workspace root and is already writable`, {
@@ -144,6 +156,10 @@ function validateRootCandidate(raw, context) {
 	}
 	return canonical;
 }
+/** The `unsupported-path` refusal, shared by the input and canonical checks. */
+function unsupportedPath(asTyped) {
+	return new RootValidationError("unsupported-path", `"${asTyped}" is a network or device path, which Windows ACL confinement cannot cover`, { reference: asTyped });
+}
 /** Assert that a canonical path is an existing directory. */
 function assertDirectory(canonical, asTyped) {
 	let stats;
@@ -164,19 +180,71 @@ function assertDirectory(canonical, asTyped) {
 * `invalid` (kept, unusable).
 * @param primaryRoot - the session workspace root the records belong to.
 * @param records - the stored records, in registry order.
+* @param platform - the platform the rules run for; defaults to `process.platform`.
 * @returns one status per record, in the same order.
 */
-function classifyStoredRoots(primaryRoot, records) {
+function classifyStoredRoots(primaryRoot, records, platform = process.platform) {
 	const primary = canonicalRoot(primaryRoot);
-	const claimed = [];
 	const duplicated = duplicatedIds(records);
-	const statuses = [];
-	for (const [index, record] of records.entries()) {
-		const status = classifyStoredRoot(record, primary, claimed, duplicated.has(record.id), index);
-		statuses.push(status);
-		if (status.state === "available") claimed.push(status.path);
+	return markMembershipConflicts(records.map((record, index) => classifyStoredRoot(record, primary, duplicated.has(record.id), index, platform)));
+}
+/**
+* Pass two of {@link classifyStoredRoots}: every pair of structurally sound
+* records whose RECORDED boundaries overlap is a membership conflict, and
+* BOTH are unusable — which side "won" must never depend on registry order
+* (a reorder is cosmetic and cannot revoke a deny boundary). Missing and
+* redirected records participate too: withheld roots carry no grant, but
+* their recorded boundaries still describe restrictions the operator has not
+* removed.
+*
+* The comparison is lexical over the recorded grant via
+* {@link isCanonicallyUnder}/{@link samePath} — never the current resolution,
+* which a replaced directory can steer. The conflict set is built from the
+* ORIGINAL first-pass statuses, so a third overlapping record is marked even
+* when the pair found first was already doomed.
+*/
+function markMembershipConflicts(statuses) {
+	const boundaries = statuses.map((status) => status.state === "invalid" ? void 0 : singleGrantOf(status));
+	const conflicts = /* @__PURE__ */ new Map();
+	for (let index = 0; index < boundaries.length; index += 1) {
+		const boundary = boundaries[index];
+		if (boundary === void 0) continue;
+		for (let other = index + 1; other < boundaries.length; other += 1) {
+			const otherBoundary = boundaries[other];
+			if (otherBoundary === void 0) continue;
+			if (samePath(boundary, otherBoundary) || isCanonicallyUnder(boundary, otherBoundary) || isCanonicallyUnder(otherBoundary, boundary)) {
+				conflicts.set(index, [...conflicts.get(index) ?? [], otherBoundary]);
+				conflicts.set(other, [...conflicts.get(other) ?? [], boundary]);
+			}
+		}
 	}
-	return statuses;
+	if (conflicts.size === 0) return [...statuses];
+	return statuses.map((status, index) => {
+		const others = conflicts.get(index);
+		if (others === void 0) return status;
+		const boundary = boundaries[index];
+		const partners = others.map((other) => `"${other}"`).join(", ");
+		return {
+			...status,
+			state: "invalid",
+			invalidReason: "membership-conflict",
+			detail: `the recorded grant "${boundary}" overlaps the recorded grant ${partners} — neither membership is granted until one registration is removed, and any recorded read-only restriction remains in force`
+		};
+	});
+}
+/**
+* The single recorded grant a record or status carries — `undefined` unless
+* EXACTLY one grant field holds a non-empty string. Shared by the conflict
+* pass and {@link reservedRootBoundary}; the stored decoder is the source of
+* the access level, so this never cross-checks the field against `access`.
+*/
+function singleGrantOf(record) {
+	const grants = [
+		record.recordedPath,
+		record.readOnlyRecordedPath,
+		record.readWriteRecordedPath
+	].filter((grant) => typeof grant === "string" && grant !== "");
+	return grants.length === 1 ? grants[0] : void 0;
 }
 /**
 * The ids that more than one record claims. Computed for the whole list up
@@ -192,15 +260,18 @@ function duplicatedIds(records) {
 	return duplicated;
 }
 /**
-* Judge one stored record against the primary root and the roots claimed before
-* it.
+* Judge one stored record's structural trust and current availability —
+* WITHOUT looking at any other record (record-vs-record overlap is the second
+* pass of {@link classifyStoredRoots}).
 *
 * Identity and the recorded directory are checked BEFORE the current
 * resolution is used for anything: a record whose path now resolves elsewhere
 * must not have its new (attacker-influenced) target participate in the
-* overlap rules.
+* overlap rules. The primary-root rules therefore judge the RECORDED
+* boundary — the directory the operator was granted — not what `path`
+* resolves to today.
 */
-function classifyStoredRoot(record, primary, claimed, duplicatedId, position) {
+function classifyStoredRoot(record, primary, duplicatedId, position, platform) {
 	const invalid = (detail) => ({
 		...record,
 		state: "invalid",
@@ -210,18 +281,24 @@ function classifyStoredRoot(record, primary, claimed, duplicatedId, position) {
 	if (typeof record.id !== "string" || record.id === "") return invalid("the record has no id");
 	if (duplicatedId) return invalid(`the id "${record.id}" is used by more than one record (entry ${position + 1})`);
 	if (!isAbsolute(record.path)) return invalid(`"${record.path}" is not an absolute path`);
-	const recorded = record.recordedPath;
+	const grants = [
+		record.recordedPath,
+		record.readOnlyRecordedPath,
+		record.readWriteRecordedPath
+	].filter((grant) => typeof grant === "string" && grant !== "");
+	if (grants.length > 1) return invalid("the record declares more than one grant (ambiguous access)");
+	const recorded = grants[0];
 	if (typeof recorded !== "string" || recorded === "") return invalid("the record does not say which directory it was granted for");
+	if (!isAbsolute(recorded)) return invalid(`the recorded grant "${recorded}" is not an absolute path`);
+	if (platform === "win32" && (isWindowsNetworkOrDevicePath(record.path) || isWindowsNetworkOrDevicePath(recorded))) return invalid(`"${record.path}" is a network or device path, which Windows ACL confinement cannot cover`);
+	if (samePath(recorded, primary)) return invalid(`"${recorded}" is this session's workspace root`);
+	if (isCanonicallyUnder(recorded, primary) || isCanonicallyUnder(primary, recorded)) return invalid(`"${recorded}" overlaps this session's workspace root`);
 	const canonical = canonicalRoot(record.path);
 	if (!samePath(canonical, recorded)) return {
 		...record,
 		state: "redirected",
 		detail: `the path now resolves to "${canonical}" instead of the registered "${recorded}"`
 	};
-	if (samePath(canonical, primary)) return invalid(`"${canonical}" is this session's workspace root`);
-	if (isCanonicallyUnder(canonical, primary) || isCanonicallyUnder(primary, canonical)) return invalid(`"${canonical}" overlaps this session's workspace root`);
-	if (claimed.some((existing) => samePath(existing, canonical))) return invalid(`"${canonical}" is registered twice`);
-	for (const existing of claimed) if (isCanonicallyUnder(canonical, existing) || isCanonicallyUnder(existing, canonical)) return invalid(`"${canonical}" overlaps the registered root "${existing}"`);
 	let isDirectory = false;
 	try {
 		isDirectory = statSync(canonical).isDirectory();
@@ -249,6 +326,26 @@ function availableRoots(statuses) {
 	return statuses.filter((status) => status.state === "available").map((status) => status.path);
 }
 /**
+* The recorded boundary one status still RESERVES: the grant it was
+* registered for, which a new or revived registration may not overlap merely
+* because the root is currently unusable.
+*
+* `available`, `missing`, `redirected`, and membership-conflict statuses all
+* carry an intact, trustworthy recorded grant; every other `invalid` verdict
+* means the grant could not be parsed at all, so it reserves — and denies —
+* nothing. This is not an independent authorization table: it derives the
+* boundary from the status list {@link classifyStoredRoots} produced, with
+* the same grant-extraction semantics, so its answer can never disagree with
+* classification.
+* @param status - one classified registration.
+* @returns the absolute recorded boundary, or `undefined` when there is none.
+*/
+function reservedRootBoundary(status) {
+	if (status.state === "invalid" && status.invalidReason !== "membership-conflict") return void 0;
+	const boundary = singleGrantOf(status);
+	return boundary !== void 0 && isAbsolute(boundary) ? boundary : void 0;
+}
+/**
 * Pair every status with the 1-based ordinal the surfaces accept for it. The
 * ordinal belongs to the POSITION, so it stays correct even for records whose
 * id is duplicated or missing — which is exactly the case where a positional
@@ -342,4 +439,4 @@ function describeRef(ref) {
 	}
 }
 //#endregion
-export { classifyStoredRoots as a, indexedStatuses as c, resolveRootIndex as d, resolveRootRef as f, canonicalRoot as i, isCanonicallyUnder as l, additionalRootId as n, entryRootRef as o, validateRootCandidate as p, availableRoots as r, expandRootInput as s, RootValidationError as t, removeStatusAt as u };
+export { classifyStoredRoots as a, indexedStatuses as c, reservedRootBoundary as d, resolveRootIndex as f, canonicalRoot as i, isCanonicallyUnder as l, validateRootCandidate as m, additionalRootId as n, entryRootRef as o, resolveRootRef as p, availableRoots as r, expandRootInput as s, RootValidationError as t, removeStatusAt as u };