@mulmoclaude/core 4.4.2 → 4.6.0

package/dist/{server-CF1qllGV.cjs → server-DXUt34Rt.cjs}

@@ -1,10 +1,10 @@
 const require_rolldown_runtime = require("./rolldown-runtime-VH7oDXx4.cjs");
 const require_dist = require("./dist-CsgSfWwR.cjs");
-const require_root = require("./root-rPH6FGDT.cjs");
+const require_root = require("./root-BvwBUcol.cjs");
 const require_relPath = require("./relPath-CTAjGdCL.cjs");
-const require_itemId = require("./itemId-CEQdK01z.cjs");
-const require_promptSafety = require("./promptSafety-C0BWDsfT.cjs");
-const require_discovery = require("./discovery-Dl9nRa-m.cjs");
+const require_itemId = require("./itemId-CGT2J7YK.cjs");
+const require_promptSafety = require("./promptSafety-Cv-SoTd4.cjs");
+const require_discovery = require("./discovery-2TvulIz8.cjs");
 const require_feeds_paths = require("./feeds/paths.cjs");
 const require_skill_bridge_index = require("./skill-bridge/index.cjs");
 let node_fs = require("node:fs");
@@ -33,27 +33,78 @@ let zod = require("zod");
 async function readCustomViewHtml(collection, viewFile, opts = {}) {
 	return readSourceAwareFile(collection, viewFile, opts);
 }
-/** Internal helper: read a file using the same source-aware base fallback as
-*  `readCustomViewHtml`. Used by both `readCustomViewHtml` and
-*  `readCustomViewI18n` so the two stay in lockstep. */
-async function readSourceAwareFile(collection, relPath, opts) {
-	const safeSlug = require_discovery.safeSlugName(collection.slug);
-	if (safeSlug === null) return null;
-	const workspaceRoot = opts.workspaceRoot ?? require_discovery.getWorkspaceRoot();
-	const staging = collection.source === "project" ? require_discovery.stagingSkillDir(workspaceRoot, safeSlug) : null;
-	const bases = staging === null ? [collection.skillDir] : [staging, collection.skillDir];
+/** `<staging>/<slug>` when THAT slug is actually staged there, else null.
+*
+*  `stagingSkillDir` only says whether the ROOT has a staging tree, and then
+*  joins the slug — so on its own it claims every collection in a staged
+*  workspace is staged. That is wrong for the two layouts that coexist there:
+*  a collection IMPORTED via the discover panel, and one committed directly
+*  under `.claude/skills/`, neither of which has a staging copy. A stale
+*  `data/skills/<slug>/views/x.html` left beside them then SHADOWED the real
+*  view on every read (#3031).
+*
+*  The evidence is the slug's own `schema.json`, because that is what the
+*  authoring layout actually produces — `putSchema` writes it, and the delete
+*  path below has always keyed on it. It must be a REGULAR FILE — `lstat`, not
+*  `stat` — so a symlink standing in for the schema is not evidence.
+*
+*  Exported so the DELETE path uses this exact function rather than a second
+*  copy of the expression: "reads and deletes agree" is a claim `views.ts` has
+*  made in its comments since #1836, and sharing the predicate is what makes
+*  it structurally true instead of a convention two files have to remember. */
+async function stagedSkillDir(workspaceRoot, safeSlug) {
+	const staging = require_discovery.stagingSkillDir(workspaceRoot, safeSlug);
+	if (staging === null) return null;
+	return await isStagedSchema(node_path.default.join(staging, "schema.json")) ? staging : null;
+}
+/** Is the staged `schema.json` there, as a regular file?
+*
+*  NOT `isRegularFile` from `io.ts`, which answers `false` for every `lstat`
+*  failure. Here "no schema" and "the schema could not be inspected" must not
+*  collapse into one answer: the second would quietly downgrade a staged slug
+*  to unstaged and serve the OTHER base's copy — the same masking the read loop
+*  below refuses, and for the same reason (Sourcery review on #3032). Only the
+*  missing-here codes mean "not staged"; anything else propagates. */
+async function isStagedSchema(target) {
+	try {
+		return (await (0, node_fs_promises.lstat)(target)).isFile();
+	} catch (err) {
+		if (!isMissingHere(err)) throw err;
+		return false;
+	}
+}
+/** The two codes that mean "not at this path" rather than "this path failed".
+*  A permission denial / disk error must propagate — silently treating it as
+*  absent masks a real failure as a stale-from-another-base success or a
+*  misleading 404 (CodeRabbit review on #1836). */
+function isMissingHere(err) {
+	return require_dist.isErrorWithCode(err) && (err.code === "ENOENT" || err.code === "ENOTDIR");
+}
+/** Read `relPath` from the first base that holds it, or null when none does.
+*  Bases are tried in order and each is containment-checked on its own, so the
+*  fallback never widens what a single base would have allowed. */
+async function readFromBases(bases, relPath) {
 	for (const base of bases) {
 		const resolved = require_discovery.resolveTemplatePath(base, relPath);
 		if (resolved === null) continue;
 		try {
 			return await (0, node_fs_promises.readFile)(resolved, "utf-8");
 		} catch (err) {
-			if (!require_dist.isErrorWithCode(err)) throw err;
-			if (err.code !== "ENOENT" && err.code !== "ENOTDIR") throw err;
+			if (!isMissingHere(err)) throw err;
 		}
 	}
 	return null;
 }
+/** Internal helper: read a file using the same source-aware base fallback as
+*  `readCustomViewHtml`. Used by both `readCustomViewHtml` and
+*  `readCustomViewI18n` so the two stay in lockstep. */
+async function readSourceAwareFile(collection, relPath, opts) {
+	const safeSlug = require_discovery.safeSlugName(collection.slug);
+	if (safeSlug === null) return null;
+	const workspaceRoot = opts.workspaceRoot ?? require_discovery.getWorkspaceRoot();
+	const staging = collection.source === "project" ? await stagedSkillDir(workspaceRoot, safeSlug) : null;
+	return readFromBases(staging === null ? [collection.skillDir] : [staging, collection.skillDir], relPath);
+}
 var I18N_FALLBACK_LOCALE = "en";
 var EMPTY_I18N = {
 	locale: "",
@@ -1267,27 +1318,20 @@ async function deleteCollection(collection, opts = {}) {
 }
 //#endregion
 //#region src/collection/server/views.ts
-async function fileExists(target) {
-	try {
-		await (0, node_fs_promises.stat)(target);
-		return true;
-	} catch (err) {
-		if (!require_dist.isErrorWithCode(err)) throw err;
-		if (err.code === "ENOENT" || err.code === "ENOTDIR") return false;
-		throw err;
-	}
-}
 /** The authoritative base dir for a collection's schema.json + view HTML.
 *  For a project collection, prefer the staging tree when its schema.json is
 *  present (authoring layout); otherwise fall back to the active skill dir
 *  (imported layout — staging never materialised). For feed / user, it's
-*  always the discovered skillDir. Matches `readCustomViewHtml` so reads and
-*  deletes agree on both layouts. */
+*  always the discovered skillDir.
+*
+*  Matches `readCustomViewHtml` so reads and deletes agree on both layouts —
+*  through the SAME function now (`stagedSkillDir`), not through two copies of
+*  one expression. The read side had drifted off it and was preferring staging
+*  per root rather than per slug (#3031), which is precisely the drift a shared
+*  predicate makes unrepresentable. */
 async function canonicalBase(collection, workspaceRoot, safeSlug) {
 	if (collection.source !== "project") return collection.skillDir;
-	const staging = require_discovery.stagingSkillDir(workspaceRoot, safeSlug);
-	if (staging !== null && await fileExists(node_path.default.join(staging, "schema.json"))) return staging;
-	return collection.skillDir;
+	return await stagedSkillDir(workspaceRoot, safeSlug) ?? collection.skillDir;
 }
 /** Every on-disk schema.json that must reflect the removal. The active
 *  `<skillDir>/schema.json` is the discovery anchor and is always present.
@@ -1297,9 +1341,9 @@ async function canonicalBase(collection, workspaceRoot, safeSlug) {
 async function schemaWriteTargets(collection, workspaceRoot, safeSlug) {
 	const active = node_path.default.join(collection.skillDir, require_discovery.SCHEMA_FILE);
 	if (collection.source !== "project") return [active];
-	const staging = require_discovery.stagingSkillDir(workspaceRoot, safeSlug);
+	const staging = await stagedSkillDir(workspaceRoot, safeSlug);
 	const targets = [];
-	if (staging !== null && await fileExists(node_path.default.join(staging, "schema.json"))) targets.push(node_path.default.join(staging, require_discovery.SCHEMA_FILE));
+	if (staging !== null) targets.push(node_path.default.join(staging, require_discovery.SCHEMA_FILE));
 	targets.push(active);
 	return targets;
 }
@@ -1878,24 +1922,53 @@ function openItemsFileRefusal(err, shown) {
 *  descriptor's inode is the one reachable at a contained path. A hardlink
 *  would satisfy it, but the agent cannot create one across the mount boundary
 *  — only the workspace is mounted, and a hardlink cannot cross filesystems. */
-async function verifyOpenedItemsFile(handle, hostPath, root, shown) {
-	const opened = await handle.stat();
+/** What the filesystem says about the path the descriptor was opened from:
+*  the link itself (is it a symlink?), the resolved target, the root resolved
+*  BY THE SAME API, and the target's stat.
+*
+*  Resolving the two sides with different apis is not a style question: on
+*  Windows `realpath` expands an 8.3 short name and `realpathSync` does not, so
+*  a root from `os.tmpdir()` compared against an async-resolved file inside it
+*  read as "outside the workspace" and refused every itemsFile (#2972). */
+async function resolveOpenedPaths(hostPath, root) {
+	const link = await (0, node_fs_promises.lstat)(hostPath);
+	const real = await (0, node_fs_promises.realpath)(hostPath);
+	return {
+		link,
+		real,
+		rootReal: await (0, node_fs_promises.realpath)(root),
+		atPath: await (0, node_fs_promises.stat)(real)
+	};
+}
+/** Judge the opened descriptor against the paths it claims to be. Returns the
+*  refusal text, or null when the descriptor is the contained file it should
+*  be. `opened` is the descriptor's own stat, so the identity check compares
+*  what was OPENED with what is reachable at the path. */
+function openedFileProblem(paths, opened, shown) {
+	if (paths.link.isSymbolicLink()) return symlinkRefusal(shown);
+	if (!require_discovery.isUnderRealRoot(paths.real, paths.rootReal)) return outsideWorkspaceRefusal(shown);
+	if (paths.atPath.ino !== opened.ino || paths.atPath.dev !== opened.dev) return `manageCollection: \`itemsFile\` '${shown}' changed while it was being opened. Nothing was read; write the file, then call putItems.`;
+	return null;
+}
+/** The descriptor's own shape: a regular file, within the byte cap. Returns the
+*  refusal text, or null. Checked before any path work — a fifo or an 8 MiB
+*  blob is refused without paying for a realpath. */
+function openedShapeProblem(opened, shown) {
 	if (!opened.isFile()) return `manageCollection: \`itemsFile\` '${shown}' is not a regular file. It must be a JSON file holding an array of record objects.`;
 	if (opened.size > 8388608) return `manageCollection: \`itemsFile\` '${shown}' is ${opened.size} bytes, over the limit of ${MAX_ITEMS_FILE_BYTES}. Nothing was read; split the rows across several files and call once per file.`;
-	let real;
-	let atPath;
-	let link;
+	return null;
+}
+async function verifyOpenedItemsFile(handle, hostPath, root, shown) {
+	const opened = await handle.stat();
+	const shapeProblem = openedShapeProblem(opened, shown);
+	if (shapeProblem !== null) return shapeProblem;
+	let paths;
 	try {
-		link = await (0, node_fs_promises.lstat)(hostPath);
-		real = await (0, node_fs_promises.realpath)(hostPath);
-		atPath = await (0, node_fs_promises.stat)(real);
+		paths = await resolveOpenedPaths(hostPath, root);
 	} catch (err) {
 		return openItemsFileRefusal(err, shown);
 	}
-	if (link.isSymbolicLink()) return symlinkRefusal(shown);
-	if (!require_discovery.isContainedInRoot(real, root)) return outsideWorkspaceRefusal(shown);
-	if (atPath.ino !== opened.ino || atPath.dev !== opened.dev) return `manageCollection: \`itemsFile\` '${shown}' changed while it was being opened. Nothing was read; write the file, then call putItems.`;
-	return { size: opened.size };
+	return openedFileProblem(paths, opened, shown) ?? { size: opened.size };
 }
 /** Open the file ONCE, then prove that descriptor is the contained file.
 *  `O_NOFOLLOW` refuses a symlink outright rather than resolving it, and
@@ -2335,7 +2408,7 @@ var MANAGE_COLLECTION_DEFINITION = {
 			},
 			schema: {
 				type: "object",
-				description: "putSchema: the full collection schema object (same shape as schema.json — title, icon, dataPath, primaryKey, fields, …). Call getSchema first for the current one, and schemaDocs for the field DSL."
+				description: "putSchema: the full collection schema object (same shape as schema.json — title, icon, dataPath, primaryKey, fields, …). `icon` is either a Material Symbols name (lowercase letters, digits and underscores only — `podcasts`, `rss_feed`, `3d_rotation`; capitals/spaces/hyphens never match) or a SINGLE emoji. Prefer an emoji when the collection would otherwise share a look-alike glyph with another one — it is in colour and tells them apart in the launcher. `color` is an OPTIONAL accent (violet | indigo | sky | teal | emerald | lime | fuchsia) drawn as a pale chip behind the launcher glyph — another way to separate collections that share a generic icon. Omit it rather than guessing; an unknown name simply draws no accent. Call getSchema first for the current one, and schemaDocs for the field DSL."
 			},
 			topic: {
 				type: "string",
@@ -2574,6 +2647,12 @@ Object.defineProperty(exports, "schemaRelations", {
 		return schemaRelations;
 	}
 });
+Object.defineProperty(exports, "stagedSkillDir", {
+	enumerable: true,
+	get: function() {
+		return stagedSkillDir;
+	}
+});
 Object.defineProperty(exports, "successorId", {
 	enumerable: true,
 	get: function() {
@@ -2593,4 +2672,4 @@ Object.defineProperty(exports, "validateRecordObject", {
 	}
 });
 
-//# sourceMappingURL=server-CF1qllGV.cjs.map
+//# sourceMappingURL=server-DXUt34Rt.cjs.map