dsh-wsl-workspace 0.7.2 → 0.7.4

package/lib/index.js

@@ -1,10 +1,10 @@
-import { defaultDistro, isAbsoluteLinuxPath, isValidWslUsername, joinUnc, listDistros, mntToWindowsPath, normalizeLinuxPath, parseWslUnc, uncToLinux } from "./wsl-CECXiGZH.js";
-import { canonicalWslUnc, getWindowsWorkspace, getWorkspaceUsername, listWorkspaceKeys, registerWindowsWorkspace, setWorkspaceUsername } from "./wsl-credentials-BJXc9tfi.js";
-import { resolveLinuxSymlinks } from "./links-BQxdJOMy.js";
+import { defaultDistro, isAbsoluteLinuxPath, isValidWslUsername, joinUnc, listDistros, mntToWindowsPath, normalizeLinuxPath, parseWslUnc, uncToLinux } from "./wsl-BTA7XT8X.js";
+import { canonicalWslUnc, getWindowsWorkspace, getWorkspaceUsername, listWorkspaceKeys, registerWindowsWorkspace, setWorkspaceUsername } from "./wsl-credentials-gFHTqaiN.js";
+import { resolveLinuxSymlinks } from "./links-DQ8GgpMj.js";
 import z from "@deepseek-ai/schemastery";
 import { cpSync, existsSync, readFileSync, readdirSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
-import { fileURLToPath } from "node:url";
-import { dirname, join, posix } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { dirname, isAbsolute, join, posix } from "node:path";
 import { homedir } from "node:os";
 import { readFile, readdir, stat } from "node:fs/promises";
 
@@ -1039,6 +1039,13 @@ const DEFAULT_ROUTE = "/wsl-workspace/api";
 * preset.yml text verbatim, so the plugin writes one bilingual string so
 * both locales can identify each variant. Custom presets keep their own
 * name.
+*
+* This table is consulted before anything the release publishes, so every id
+* the mode has ever carried needs an entry. `code` was the id up to
+* `0.1.0-rc.8` and `ptc` is the id from `0.1.1` on; without the `ptc` entry the
+* lookup returned undefined and the variant fell through to the release's own
+* display name — which `0.1.7` does not publish at all, leaving the mode named
+* `WSL · ptc` with the generic description `WSL execution world for ptc: …`.
 */
 const MODE_DISPLAY_LABELS = {
 	standard: {
@@ -1049,6 +1056,10 @@ const MODE_DISPLAY_LABELS = {
 		en: "Code mode",
 		zh: "PTC 模式"
 	},
+	ptc: {
+		en: "PTC mode",
+		zh: "PTC 模式"
+	},
 	minimal: {
 		en: "Minimal mode",
 		zh: "极简模式"
@@ -1286,6 +1297,81 @@ async function dispatch(method, params) {
 	}
 }
 /**
+* Read one preset's declared composition across both roster generations.
+* @param agentPresets - the roster face.
+* @param preset - the roster entry to read.
+* @returns the composition text, plus the display name when the face publishes it.
+*/
+async function readPresetComposition(agentPresets, preset) {
+	if (typeof agentPresets.readDocument === "function") {
+		const document = await agentPresets.readDocument(preset.id);
+		return document.name === void 0 ? { content: document.content } : {
+			content: document.content,
+			name: document.name
+		};
+	}
+	if (typeof agentPresets.read === "function") return { content: await agentPresets.read(preset.id) };
+	throw new Error(`agentPresets: this DSH release exposes neither readDocument() nor read() (preset "${preset.id}")`);
+}
+/**
+* Parse one transformed composition back into declaration rows.
+*
+* The composition is the entry-list YAML dialect, whose `!!js` scalars are
+* expression nodes the Loader evaluates when it activates the row.
+* `@deepseek-ai/cordis-plugin-include` exports `entryListSchema` precisely so
+* config tooling can round-trip that dialect, and it is the same schema the
+* harness parses preset patches with. Parsing the text back is what lets the
+* (text-level) WSL transform keep working unchanged now that a variant is a
+* declaration row instead of a directory of YAML.
+*
+* Both modules are resolved at call time rather than at module load: they are
+* Host-provided (`dsh` depends on `cordis-plugin-include`, which depends on
+* `js-yaml`), and a release that ever drops them must fail this one variant
+* rather than refuse to load the whole plugin.
+* @param content - the variant composition text.
+* @returns the declaration's plugin rows.
+*/
+async function parseVariantComposition(content) {
+	const includeSpecifier = "@deepseek-ai/cordis-plugin-include";
+	const yamlSpecifier = "js-yaml";
+	const [include, yamlModule] = await Promise.all([import(includeSpecifier), import(yamlSpecifier)]);
+	const load = yamlModule.load ?? yamlModule.default?.load;
+	if (typeof load !== "function") throw new Error("js-yaml: no load() export");
+	const rows = load(content, { schema: include.entryListSchema });
+	if (!Array.isArray(rows)) throw new Error("the transformed composition did not parse as an entry list");
+	return toImportableSpecifiers(rows);
+}
+/**
+* Rewrite every absolute local module specifier as a `file:` URL.
+*
+* The generated world names THIS package's built providers (`shell.js`,
+* `fs.js`, …) by absolute path. That is what the directory mechanism needed:
+* those rows sat in an Include-backed tree, and the boot-time Include
+* translates an absolute path into a `file:` URL before importing it. A preset
+* mounted from a *declaration* is loaded by the registry's own entry tree,
+* which has no such translation — handing it `C:/…/lib/shell.js` leaves those
+* rows without a fiber, the audit reports them "never started", and the whole
+* variant is refused. Rewriting the specifier is therefore part of adapting to
+* the declaration mechanism, not a change to what the variant mounts.
+*
+* Only `name` is touched: config values (the relay path handed to the PTY
+* backend, the interpreter path in `shellPath`) must stay native filesystem
+* paths. Group rows carry their children in a `config` array, so those are
+* walked too.
+* @param rows - the parsed declaration rows.
+* @returns the same rows with their module specifiers made importable.
+*/
+function toImportableSpecifiers(rows) {
+	const rewrite = (row) => {
+		if (row === null || typeof row !== "object") return row;
+		const entry = row;
+		if (typeof entry.name === "string" && isAbsolute(entry.name)) entry.name = pathToFileURL(entry.name).href;
+		if (Array.isArray(entry.config)) entry.config = entry.config.map(rewrite);
+		return row;
+	};
+	return rows.map(rewrite);
+}
+/**
 * Publish a fully staged preset directory while preserving the last complete
 * variant if publication fails. Stable sibling names also let the next boot
 * recover an interrupted old-to-backup rename before doing new work.
@@ -1378,7 +1464,7 @@ async function waitForSubprocess(ctx) {
 	return void 0;
 }
 /** Materialize one WSL variant per healthy source preset. */
-async function materializeVariants(agentPresets, dshHome, paths, persistentShell) {
+async function materializeVariants(agentPresets, dshHome, paths, persistentShell, track) {
 	const presets = await agentPresets.list();
 	const userRoot = join(dshHome, ".agent-presets");
 	const generated = /* @__PURE__ */ new Set();
@@ -1386,12 +1472,25 @@ async function materializeVariants(agentPresets, dshHome, paths, persistentShell
 		if (preset.broken !== void 0) continue;
 		if (isWslVariantId(preset.id)) continue;
 		const variantId = variantIdFor(preset.id);
-		const source = await agentPresets.read(preset.id);
-		const transformed = transformPresetForWsl(source, paths.shell, paths.fs, persistentShell ? {
+		const composition = await readPresetComposition(agentPresets, preset);
+		const transformed = transformPresetForWsl(composition.content, paths.shell, paths.fs, persistentShell ? {
 			relayPath: paths.relay,
 			nodePath: paths.node,
 			sandboxPath: paths.sandbox
 		} : void 0, paths.search, paths.jobs);
+		if (typeof agentPresets.register === "function") {
+			const plugins = await parseVariantComposition(transformed);
+			const declaration = {
+				id: variantId,
+				name: variantName(preset.id, composition.name ?? preset.name ?? preset.id),
+				description: variantDescription(preset.id),
+				...preset.order === void 0 ? {} : { order: preset.order },
+				plugins
+			};
+			track(await agentPresets.register(declaration));
+			continue;
+		}
+		if (preset.path === void 0) throw new Error(`agentPresets: roster entry "${preset.id}" carries no path on this release`);
 		const dir = join(userRoot, variantId);
 		const staging = `${dir}.staging`;
 		rmSync(staging, {
@@ -1419,17 +1518,11 @@ async function materializeVariants(agentPresets, dshHome, paths, persistentShell
 		publishVariant(staging, dir);
 		generated.add(variantId);
 	}
-	for (const entry of readdirSync(userRoot, { withFileTypes: true })) {
+	if (existsSync(userRoot)) for (const entry of readdirSync(userRoot, { withFileTypes: true })) {
 		if (!entry.isDirectory()) continue;
-		if (entry.name === "wsl") {
-			rmSync(join(userRoot, entry.name), {
-				recursive: true,
-				force: true
-			});
-			continue;
-		}
-		if (!/^wsl-[a-z0-9-]+$/.test(entry.name)) continue;
-		if (!generated.has(entry.name)) rmSync(join(userRoot, entry.name), {
+		if (!/^wsl(-[a-z0-9-]+)?$/.test(entry.name)) continue;
+		if (generated.has(entry.name)) continue;
+		rmSync(join(userRoot, entry.name), {
 			recursive: true,
 			force: true
 		});
@@ -1463,6 +1556,17 @@ function apply(ctx, config) {
 	const nodePath = process.execPath.replace(/\\/g, "/");
 	const agentPresets = ctx.get("agentPresets");
 	if (agentPresets !== void 0) ctx.effect(() => {
+		let stopped = false;
+		const disposers = [];
+		const track = (dispose) => {
+			if (typeof dispose !== "function") return;
+			const retire = dispose;
+			if (stopped) {
+				Promise.resolve(retire()).catch(() => {});
+				return;
+			}
+			disposers.push(retire);
+		};
 		(async () => {
 			const persistentShell = await supportsPersistentShell(ctx);
 			await materializeVariants(agentPresets, dshHome, {
@@ -1473,11 +1577,14 @@ function apply(ctx, config) {
 				sandbox: sandboxPath,
 				search: searchPath,
 				jobs: jobsPath
-			}, persistentShell);
+			}, persistentShell, track);
 		})().catch((error) => {
 			console.error(`dsh-wsl-workspace: WSL preset-variant generation failed: ${messageOf(error)}`);
 		});
-		return () => {};
+		return () => {
+			stopped = true;
+			for (const retire of disposers.splice(0, disposers.length)) Promise.resolve(retire()).catch(() => {});
+		};
 	}, "dsh-wsl-workspace: WSL preset variants");
 	const skills = ctx.get("skills");
 	if (skills !== void 0 && typeof skills.registerProvider === "function") ctx.effect(() => skills.registerProvider((control) => new WslSkillsProvider(control)), "dsh-wsl-workspace: WSL workspace skills provider");