openmeld 0.3.159 → 0.3.160

package/dist/installer-CLPF4DHx.js

@@ -0,0 +1,1100 @@
+#!/usr/bin/env node
+
+import { lt as resolveOpenMeldEnvPreset, mt as skillsDir, pt as runtimeLogsDir, tt as openMeldRootDir } from "./lock-VfUd0-tH.js";
+import { An as canManageRegistryAgentSkillTargets, Mn as resolveSkillsAgentRegistry, Xa as OPENMELD_VERSION, jn as detectInstalledSkillsAgents, qo as compareSemver } from "./openmeld-tools-update-coordinator-C7JyBdik.js";
+import { v as isBinaryDistribution } from "./auth-session-DnS-Axyz.js";
+import { T as updateConfiguredSkillsConfig, g as getConfiguredSkillsConfig, y as resolveRuntimeSkillsCustomTargetId } from "./base-url-CgF_v0Ue.js";
+import path, { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
+import { createHash, randomUUID, verify } from "node:crypto";
+import { cp, lstat, mkdir, readFile, readdir, readlink, realpath, rename, rm, stat, symlink, writeFile } from "node:fs/promises";
+import * as z$1 from "zod/v4";
+import { existsSync } from "node:fs";
+import process$1 from "node:process";
+import { fileURLToPath } from "node:url";
+import { AsyncLocalStorage } from "node:async_hooks";
+const OFFICIAL_CLI_SKILL_URL = "https://openmeld.ai/skills/openmeld-cli/SKILL.md";
+const OFFICIAL_CLI_SKILL_PUBLIC_KEY = `-----BEGIN PUBLIC KEY-----
+MCowBQYDK2VwAyEAFZjFHrQ/QLsJQpHkAbKBRG57fEazhm7zc0dMa54ilWQ=
+-----END PUBLIC KEY-----
+`;
+const officialCliSkillPayloadSchema = z$1.object({
+	schemaVersion: z$1.literal(1),
+	revision: z$1.number().int().positive(),
+	minimumCliVersion: z$1.string().regex(/^\d+\.\d+\.\d+$/),
+	contractVersion: z$1.string().min(1).max(128),
+	files: z$1.array(z$1.object({
+		path: z$1.string().regex(/^(?:SKILL\.md|(?:playbooks|references)\/[a-z0-9-]+\.md)$/),
+		content: z$1.string().min(1).max(131072)
+	}).strict()).min(1).max(32)
+}).strict().superRefine((value, context) => {
+	const paths = value.files.map((file) => file.path);
+	if (!paths.includes("SKILL.md") || new Set(paths).size !== paths.length) context.addIssue({
+		code: "custom",
+		message: "Skill entry is required and paths must be unique"
+	});
+});
+const officialCliSkillReleaseSchema = z$1.object({
+	payload: z$1.string().min(1).max(524288),
+	signature: z$1.string().regex(/^[A-Za-z0-9+/]{86}==$/)
+}).strict();
+const officialCliSkillChannelSchema = z$1.object({
+	schemaVersion: z$1.literal(1),
+	releases: z$1.array(officialCliSkillReleaseSchema).min(1).max(16)
+}).strict();
+//#endregion
+//#region src/skills/content-hash.ts
+async function computeDirectoryContentHash(input) {
+	const ignoredNames = new Set(input.ignoredNames ?? []);
+	const files = await collectFiles({
+		dir: input.rootDir,
+		rootDir: input.rootDir,
+		ignoredNames
+	});
+	const hash = createHash("sha256");
+	for (const file of files) {
+		hash.update(`file:${file.relativePath}\n`);
+		hash.update(file.content);
+		hash.update("\n");
+	}
+	return hash.digest("hex");
+}
+async function collectFiles(input) {
+	const entries = await readdir(input.dir, { withFileTypes: true }).catch((error) => {
+		if (getErrorCode$1(error) === "ENOENT") return [];
+		warnDirectoryReadError(input.dir, error);
+		throw error;
+	});
+	entries.sort((a, b) => a.name.localeCompare(b.name));
+	const files = [];
+	for (const entry of entries) {
+		if (input.ignoredNames.has(entry.name)) continue;
+		const absolutePath = join(input.dir, entry.name);
+		if (entry.isDirectory()) {
+			files.push(...await collectFiles({
+				dir: absolutePath,
+				rootDir: input.rootDir,
+				ignoredNames: input.ignoredNames
+			}));
+			continue;
+		}
+		if (!entry.isFile()) continue;
+		const content = await readFile(absolutePath);
+		files.push({
+			relativePath: normalizeRelativePath(relative(input.rootDir, absolutePath)),
+			content
+		});
+	}
+	return files;
+}
+function normalizeRelativePath(value) {
+	return value.split("\\").join("/");
+}
+function getErrorCode$1(error) {
+	if (!error || typeof error !== "object") return;
+	const code = error.code;
+	return typeof code === "string" ? code : void 0;
+}
+function warnDirectoryReadError(dir, error) {
+	const reason = error instanceof Error ? error.message : String(error);
+	process.stderr.write(`[openmeld] failed to read directory while hashing skills content (${dir}): ${reason}\n`);
+}
+//#endregion
+//#region src/skills/bundled.ts
+const CLI_PACKAGE_JSON = "package.json";
+/**
+* Locate the on-disk bundled skills directory for the npm distribution by
+* walking up from this module to the CLI package root (a directory that has
+* both package.json and skills/). Returns null under the binary distribution,
+* where import.meta.url is a virtual path and the skills are embedded instead —
+* callers in that mode go through bundled-assets.ts, not this function.
+*/
+function resolveBundledSkillsLocation() {
+	const cliRootDir = resolveCliRootDir(path.dirname(fileURLToPath(import.meta.url)));
+	if (!cliRootDir) return null;
+	return {
+		cliRootDir,
+		skillsRootDir: path.join(cliRootDir, "skills")
+	};
+}
+function resolveCliRootDir(fromDir) {
+	let current = fromDir;
+	for (;;) {
+		const hasPackageJson = existsSync(path.join(current, CLI_PACKAGE_JSON));
+		const hasSkillsDir = existsSync(path.join(current, "skills"));
+		if (hasPackageJson && hasSkillsDir) return current;
+		const parent = path.dirname(current);
+		if (parent === current) return null;
+		current = parent;
+	}
+}
+//#endregion
+//#region src/skills/bundled-assets-fs.ts
+/**
+* npm-distribution source: read the bundled skills from the on-disk `skills/`
+* directory next to the CLI package. Assets are sorted by relative path so the
+* order (and therefore any content hash computed from them) is stable and
+* matches the embedded distribution.
+*/
+async function loadFsBundledSkillAssets() {
+	const location = resolveBundledSkillsLocation();
+	if (!location) throw new Error("unable to resolve bundled OpenMeld skills directory");
+	return sortBundledSkillAssets(await collectSkillAssets(location.skillsRootDir, location.skillsRootDir));
+}
+function sortBundledSkillAssets(assets) {
+	return [...assets].sort((left, right) => left.relativePath.localeCompare(right.relativePath));
+}
+async function collectSkillAssets(dir, rootDir) {
+	const entries = await readdir(dir, { withFileTypes: true });
+	const assets = [];
+	for (const entry of entries) {
+		const absolutePath = join(dir, entry.name);
+		if (entry.isDirectory()) {
+			assets.push(...await collectSkillAssets(absolutePath, rootDir));
+			continue;
+		}
+		if (!entry.isFile()) continue;
+		assets.push({
+			relativePath: toPosixRelativePath(relative(rootDir, absolutePath)),
+			content: await readFile(absolutePath)
+		});
+	}
+	return assets;
+}
+function toPosixRelativePath(value) {
+	return value.split("\\").join("/");
+}
+//#endregion
+//#region src/skills/bundled-assets.ts
+/**
+* Load the OpenMeld-managed skill files that ship with this CLI build.
+*
+* - npm distribution: read from the on-disk `skills/` directory.
+* - binary distribution: read from files embedded into the single binary at
+*   compile time. The embedded module is a Bun-only island resolved only by
+*   `bun build --compile`; the npm build never reaches this branch and marks
+*   the module external, so its `with { type: "file" }` imports are never
+*   parsed by tsdown.
+*/
+async function loadBundledSkillAssets() {
+	if (isBinaryDistribution()) return (await import("./skills/bundled-assets-embedded")).loadEmbeddedBundledSkillAssets();
+	return loadFsBundledSkillAssets();
+}
+/**
+* Content hash over an ordered list of skill assets. Byte-for-byte compatible
+* with `computeDirectoryContentHash` (same `file:<relativePath>\n<content>\n`
+* framing) so the embedded and on-disk sources produce identical hashes as long
+* as `assets` is sorted by relative path (as `loadBundledSkillAssets` returns
+* it). This is the single skills-hash algorithm for both distribution forms.
+*/
+function hashBundledSkillAssets(assets) {
+	const hash = createHash("sha256");
+	for (const asset of assets) {
+		hash.update(`file:${asset.relativePath}\n`);
+		hash.update(asset.content);
+		hash.update("\n");
+	}
+	return hash.digest("hex");
+}
+//#endregion
+//#region src/skills/install-lock.ts
+const heldLock = new AsyncLocalStorage();
+const pendingLocks = /* @__PURE__ */ new Map();
+function withSkillsInstallLock(run) {
+	if (heldLock.getStore()) return run();
+	const key = runtimeLogsDir();
+	const current = (pendingLocks.get(key) ?? Promise.resolve()).catch(() => void 0).then(() => acquireSkillsInstallLock(() => heldLock.run(true, run)));
+	pendingLocks.set(key, current);
+	return current.finally(() => {
+		if (pendingLocks.get(key) === current) pendingLocks.delete(key);
+	});
+}
+const LOCK_FILE_NAME = "skills-install.lock";
+const LOCK_ACQUIRE_MAX_ATTEMPTS = 3;
+async function acquireSkillsInstallLock(run) {
+	const logsDir = runtimeLogsDir();
+	await mkdir(logsDir, { recursive: true });
+	const lockPath = join(logsDir, LOCK_FILE_NAME);
+	let acquired = false;
+	const lockContents = `${JSON.stringify({
+		pid: process.pid,
+		createdAt: (/* @__PURE__ */ new Date()).toISOString()
+	})}\n`;
+	for (let attempt = 0; attempt < LOCK_ACQUIRE_MAX_ATTEMPTS; attempt += 1) try {
+		await writeFile(lockPath, lockContents, {
+			encoding: "utf8",
+			flag: "wx"
+		});
+		acquired = true;
+		break;
+	} catch (error) {
+		if (getErrorCode(error) !== "EEXIST") throw error;
+		if (!await recoverStaleSkillsInstallLock(lockPath)) throw new Error("another skills installation is already running; retry after it finishes");
+		try {
+			await writeFile(lockPath, lockContents, {
+				encoding: "utf8",
+				flag: "wx"
+			});
+			acquired = true;
+			break;
+		} catch (retryError) {
+			if (getErrorCode(retryError) !== "EEXIST") throw retryError;
+		}
+	}
+	if (!acquired) throw new Error("another skills installation is already running; retry after it finishes");
+	try {
+		return await run();
+	} finally {
+		await rm(lockPath, { force: true }).catch(() => void 0);
+	}
+}
+async function recoverStaleSkillsInstallLock(lockPath) {
+	const lockRaw = await readFile(lockPath, "utf8").catch((error) => {
+		if (getErrorCode(error) === "ENOENT") return "";
+		throw error;
+	});
+	if (!lockRaw) return true;
+	const pid = resolveLockPid(parseLockMeta(lockRaw));
+	if (!pid) {
+		const metadata = await stat(lockPath).catch(() => null);
+		if (metadata && Date.now() - metadata.mtimeMs < 3e4) return false;
+	}
+	if (pid && isPidAlive(pid)) return false;
+	const latestLockRaw = await readFile(lockPath, "utf8").catch((error) => {
+		if (getErrorCode(error) === "ENOENT") return "";
+		throw error;
+	});
+	if (!latestLockRaw) return true;
+	if (!isSameLockSnapshot({
+		beforeRaw: lockRaw,
+		beforePid: pid,
+		afterRaw: latestLockRaw,
+		afterPid: resolveLockPid(parseLockMeta(latestLockRaw))
+	})) return false;
+	await rm(lockPath, { force: true }).catch((error) => {
+		if (getErrorCode(error) === "ENOENT") return;
+		throw error;
+	});
+	return true;
+}
+function parseLockMeta(value) {
+	try {
+		return JSON.parse(value);
+	} catch {
+		return null;
+	}
+}
+function resolveLockPid(meta) {
+	if (!meta || typeof meta !== "object") return null;
+	const pid = meta.pid;
+	return typeof pid === "number" && Number.isInteger(pid) && pid > 0 ? pid : null;
+}
+function isPidAlive(pid) {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch (error) {
+		return getErrorCode(error) !== "ESRCH";
+	}
+}
+function getErrorCode(error) {
+	if (!error || typeof error !== "object") return;
+	const code = error.code;
+	return typeof code === "string" ? code : void 0;
+}
+function isSameLockSnapshot(input) {
+	if (input.beforeRaw !== input.afterRaw) return false;
+	return input.beforePid === input.afterPid;
+}
+//#endregion
+//#region src/skills/official-release.ts
+const CACHE_FILE = "official-cli-skill.json";
+function verifyOfficialSkillRelease(value) {
+	const envelope = officialCliSkillReleaseSchema.safeParse(value);
+	if (!(envelope.success && verify(null, Buffer.from(envelope.data.payload), OFFICIAL_CLI_SKILL_PUBLIC_KEY, Buffer.from(envelope.data.signature, "base64")))) throw new Error("OpenMeld Skill signature is invalid");
+	const payload = officialCliSkillPayloadSchema.safeParse(JSON.parse(envelope.data.payload));
+	if (!payload.success) throw new Error("OpenMeld Skill content is invalid");
+	return {
+		release: envelope.data,
+		payload: payload.data
+	};
+}
+function isCompatible(payload, cliVersion = OPENMELD_VERSION) {
+	return payload.contractVersion === "openmeld-skills-contract-2026-08-tool-owned-actions-v2" && compareSemver(cliVersion, payload.minimumCliVersion) >= 0;
+}
+function selectOfficialSkillRelease(value, cliVersion = OPENMELD_VERSION) {
+	const channel = officialCliSkillChannelSchema.safeParse(value);
+	if (!channel.success) throw new Error("OpenMeld Skill channel is invalid");
+	return channel.data.releases.map(verifyOfficialSkillRelease).filter(({ payload }) => isCompatible(payload, cliVersion)).sort((a, b) => b.payload.revision - a.payload.revision)[0] ?? null;
+}
+async function readCachedRelease() {
+	const raw = await readFile(join(openMeldRootDir(), CACHE_FILE), "utf8").catch((error) => {
+		if (error.code === "ENOENT") return null;
+		throw error;
+	});
+	if (!raw) return null;
+	try {
+		return verifyOfficialSkillRelease(JSON.parse(raw));
+	} catch (error) {
+		process.stderr.write(`[openmeld] cached Skill rejected: ${error instanceof Error ? error.message : String(error)}\n`);
+		return null;
+	}
+}
+async function loadSelectedSkillAssets() {
+	const cached = await readCachedRelease();
+	if (!(cached && isCompatible(cached.payload))) return {
+		assets: await loadBundledSkillAssets(),
+		version: OPENMELD_VERSION
+	};
+	return {
+		assets: [...cached.payload.files.map((file) => ({
+			relativePath: `openmeld-cli/${file.path}`,
+			content: Buffer.from(file.content)
+		}))].sort((a, b) => a.relativePath.localeCompare(b.relativePath)),
+		version: `skill-r${cached.payload.revision}`,
+		contentRelease: {
+			revision: cached.payload.revision,
+			minimumCliVersion: cached.payload.minimumCliVersion
+		}
+	};
+}
+async function readSelectedSkillDocument(path) {
+	const { assets } = await loadSelectedSkillAssets();
+	const asset = assets.find((file) => file.relativePath === `openmeld-cli/${path}`);
+	if (!asset) throw new Error(`OpenMeld Skill document is missing: ${path}`);
+	return asset.content.toString("utf8");
+}
+function resolveOfficialSkillChannelUrl() {
+	if (resolveOpenMeldEnvPreset() === "prod") return "https://openmeld.ai/skills/openmeld-cli/channel.json";
+	const override = process.env.OPENMELD_CLI_SKILL_CHANNEL_URL;
+	if (!(override && process.env.OPENMELD_HOME)) return null;
+	const url = new URL(override);
+	if (url.protocol !== "http:" || ![
+		"localhost",
+		"127.0.0.1",
+		"[::1]"
+	].includes(url.hostname) || url.username || url.password) throw new Error("Isolated Skill updates require an explicit localhost URL");
+	return url.href;
+}
+async function downloadOfficialSkillUpdate() {
+	const url = resolveOfficialSkillChannelUrl();
+	if (!url) return "lane_isolated";
+	const response = await fetch(url, {
+		signal: AbortSignal.timeout(5e3),
+		redirect: "error"
+	});
+	if (!(response.ok && response.body)) throw new Error(`OpenMeld Skill download failed (HTTP ${response.status})`);
+	const chunks = [];
+	let size = 0;
+	for await (const chunk of response.body) {
+		size += chunk.byteLength;
+		if (size > 1048576) throw new Error("OpenMeld Skill download exceeds the size limit");
+		chunks.push(chunk);
+	}
+	const selected = selectOfficialSkillRelease(JSON.parse(Buffer.concat(chunks).toString("utf8")));
+	if (!selected) return "incompatible";
+	return withSkillsInstallLock(async () => {
+		const cached = await readCachedRelease();
+		if (cached && cached.payload.revision >= selected.payload.revision) return "current";
+		await mkdir(openMeldRootDir(), { recursive: true });
+		const cache = join(openMeldRootDir(), CACHE_FILE);
+		const staged = `${cache}.${randomUUID()}.tmp`;
+		try {
+			await writeFile(staged, JSON.stringify(selected.release), {
+				flag: "wx",
+				mode: 384
+			});
+			await rename(staged, cache);
+		} finally {
+			await rm(staged, { force: true });
+		}
+		return "updated";
+	});
+}
+//#endregion
+//#region src/skills/replace-directory.ts
+async function recoverSkillReplacement(target) {
+	const previous = join(dirname(target), `.${basename(target)}.openmeld-previous`);
+	if (!await exists(previous)) return;
+	if (!await isManagedReplacement(previous, basename(target))) throw new Error("OpenMeld Skill backup conflicts with an unmanaged path");
+	if (await exists(target)) {
+		if (!await isManagedReplacement(target, basename(target))) throw new Error("OpenMeld Skill recovery would affect an unmanaged path");
+		await rm(previous, {
+			recursive: true,
+			force: true
+		});
+	} else await rename(previous, target);
+}
+async function replaceSkillDirectory(target, prepare) {
+	await recoverSkillReplacement(target);
+	const staged = join(dirname(target), `.${basename(target)}.openmeld-staged-${randomUUID()}`);
+	const previous = join(dirname(target), `.${basename(target)}.openmeld-previous`);
+	try {
+		await prepare(staged);
+		const hadPrevious = await exists(target);
+		if (hadPrevious) await rename(target, previous);
+		try {
+			await rename(staged, target);
+		} catch (error) {
+			if (hadPrevious) await rename(previous, target);
+			throw error;
+		}
+		await rm(previous, {
+			recursive: true,
+			force: true
+		}).catch(() => void 0);
+	} finally {
+		await rm(staged, {
+			recursive: true,
+			force: true
+		}).catch(() => void 0);
+	}
+}
+async function isManagedReplacement(path, skillId) {
+	const raw = await readFile(join(path, ".openmeld-skill.json"), "utf8").catch(() => null);
+	if (raw) try {
+		const marker = JSON.parse(raw);
+		return marker.managedBy === "openmeld" && marker.skillId === skillId;
+	} catch {
+		return false;
+	}
+	if ((await lstat(path)).isSymbolicLink()) {
+		const destination = resolve(dirname(path), await readlink(path));
+		return basename(destination) === skillId && !await exists(destination);
+	}
+	return false;
+}
+function exists(path) {
+	return lstat(path).then(() => true, (error) => {
+		if (error.code === "ENOENT") return false;
+		throw error;
+	});
+}
+//#endregion
+//#region src/skills/store.ts
+const OPENMELD_SKILL_MARKER_FILE = ".openmeld-skill.json";
+const OPENMELD_CLI_SKILL_FILE = "SKILL.md";
+const SKILL_NAME_REGEX = /^name:\s*(.+)$/m;
+function ensureLocalSkills() {
+	return withSkillsInstallLock(ensureLocalSkillsLocked);
+}
+async function ensureLocalSkillsLocked() {
+	const storePath = skillsDir();
+	await mkdir(storePath, { recursive: true });
+	const { assets, version: bundledVersion } = await loadSelectedSkillAssets();
+	if (assets.length === 0) return listLocalSkills();
+	const skillGroups = groupAssetsBySkill(assets);
+	for (const [skillId, skillAssets] of skillGroups) {
+		const targetDir = join(storePath, skillId);
+		await recoverSkillReplacement(targetDir);
+		const sourceContentHash = hashBundledSkillAssets(skillAssets);
+		const existingMarker = await readOpenMeldSkillMarker(targetDir);
+		const existing = await lstat(targetDir).catch((error) => {
+			if (error.code === "ENOENT") return null;
+			throw error;
+		});
+		if (existing && (!existingMarker || existing.isSymbolicLink())) throw new Error(`OpenMeld Skill source conflicts with an unmanaged path: ${targetDir}`);
+		if (existingMarker?.managedBy === "openmeld" && existingMarker.skillId === skillId && existingMarker.mode === "source" && existingMarker.contentHash === sourceContentHash && existingMarker.version === bundledVersion && await computeDirectoryContentHash({
+			rootDir: targetDir,
+			ignoredNames: [".openmeld-skill.json"]
+		}) === sourceContentHash) continue;
+		await replaceSkillDirectory(targetDir, async (stagedDir) => {
+			for (const asset of skillAssets) {
+				const filePath = join(stagedDir, asset.relativePath);
+				await mkdir(dirname(filePath), { recursive: true });
+				await writeFile(filePath, asset.content);
+			}
+			await writeOpenMeldSkillMarker({
+				skillDir: stagedDir,
+				skillId,
+				mode: "source",
+				contentHash: sourceContentHash,
+				version: bundledVersion
+			});
+		});
+	}
+	return listLocalSkills();
+}
+function groupAssetsBySkill(assets) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const asset of assets) {
+		const slashIndex = asset.relativePath.indexOf("/");
+		if (slashIndex < 0) continue;
+		const skillId = asset.relativePath.slice(0, slashIndex);
+		const skillRelativePath = asset.relativePath.slice(slashIndex + 1);
+		const group = groups.get(skillId) ?? [];
+		group.push({
+			relativePath: skillRelativePath,
+			content: asset.content
+		});
+		groups.set(skillId, group);
+	}
+	for (const [skillId, group] of [...groups.entries()]) if (group.some((asset) => asset.relativePath === OPENMELD_CLI_SKILL_FILE)) groups.set(skillId, sortBundledSkillAssets(group));
+	else groups.delete(skillId);
+	return groups;
+}
+async function listLocalSkills() {
+	const storePath = skillsDir();
+	const skillDirs = await discoverSkillDirs(storePath, 0, 6);
+	const skills = [];
+	for (const skillDir of skillDirs) {
+		const raw = await readFile(join(skillDir, "SKILL.md"), "utf8").catch(() => "");
+		if (!raw) continue;
+		const skillId = path.basename(skillDir);
+		const skillName = readSkillName(raw) ?? skillId;
+		const marker = await readOpenMeldSkillMarker(skillDir);
+		skills.push({
+			id: skillId,
+			name: skillName,
+			absolutePath: skillDir,
+			relativePath: relative(storePath, skillDir) || skillId,
+			...marker?.contentHash ? { contentHash: marker.contentHash } : {},
+			...marker?.version ? { version: marker.version } : {}
+		});
+	}
+	skills.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+	return skills;
+}
+async function writeOpenMeldSkillMarker(input) {
+	const markerPath = join(input.skillDir, OPENMELD_SKILL_MARKER_FILE);
+	const marker = {
+		managedBy: "openmeld",
+		skillId: input.skillId,
+		mode: input.mode,
+		...input.contentHash ? { contentHash: input.contentHash } : {},
+		...input.version ? { version: input.version } : {},
+		updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+	await writeFile(markerPath, `${JSON.stringify(marker, null, 2)}\n`, "utf8");
+}
+async function isOpenMeldManagedSkillDir(skillDir) {
+	return (await readOpenMeldSkillMarker(skillDir))?.managedBy === "openmeld";
+}
+async function readOpenMeldSkillMarker(skillDir) {
+	const raw = await readFile(join(skillDir, OPENMELD_SKILL_MARKER_FILE), "utf8").catch(() => null);
+	if (!raw) return null;
+	try {
+		const parsed = JSON.parse(raw);
+		if (parsed.managedBy !== "openmeld") return null;
+		if (typeof parsed.skillId !== "string" || parsed.skillId.trim().length === 0) return null;
+		if (parsed.mode !== "source" && parsed.mode !== "symlink" && parsed.mode !== "copy") return null;
+		return {
+			managedBy: "openmeld",
+			skillId: parsed.skillId.trim(),
+			mode: parsed.mode,
+			...typeof parsed.contentHash === "string" && parsed.contentHash.trim().length > 0 ? { contentHash: parsed.contentHash.trim() } : {},
+			...typeof parsed.version === "string" && parsed.version.trim().length > 0 ? { version: parsed.version.trim() } : {},
+			updatedAt: typeof parsed.updatedAt === "string" && parsed.updatedAt.trim().length > 0 ? parsed.updatedAt : (/* @__PURE__ */ new Date()).toISOString()
+		};
+	} catch {
+		return null;
+	}
+}
+async function discoverSkillDirs(dir, depth, maxDepth) {
+	if (depth > maxDepth) return [];
+	const entries = await readdir(dir, { withFileTypes: true }).catch(() => []);
+	if (entries.length === 0) return [];
+	if (entries.some((entry) => entry.isFile() && entry.name === "SKILL.md")) return [dir];
+	return (await Promise.all(entries.filter((entry) => entry.isDirectory() && !entry.name.includes(".openmeld-")).map((entry) => discoverSkillDirs(join(dir, entry.name), depth + 1, maxDepth)))).flat();
+}
+function readSkillName(rawSkillFile) {
+	const match = rawSkillFile.match(SKILL_NAME_REGEX);
+	if (!match) return;
+	const candidate = match[1]?.trim();
+	return candidate && candidate.length > 0 ? candidate : void 0;
+}
+//#endregion
+//#region src/skills/state.ts
+async function resolveSkillsInstallStates(input) {
+	const states = [];
+	for (const target of input.targets) for (const skill of input.skills) states.push(await resolveSkillInstallStateForTarget({
+		skill,
+		target
+	}));
+	return states;
+}
+async function resolveSkillInstallStateForTarget(input) {
+	const base = createBaseResult(input);
+	const source = await resolveSourceSnapshot(input.skill);
+	const target = await resolveTargetSnapshot(base.skillDir);
+	if (!target.exists) return createStateResult({
+		base,
+		source,
+		state: "missing"
+	});
+	if (target.marker?.managedBy !== "openmeld") {
+		if (isLegacyOpenMeldSkillSymlink({
+			skillId: input.skill.id,
+			target
+		})) return createStateResult({
+			base,
+			source,
+			state: "outdated",
+			targetMode: "symlink",
+			reason: "legacy OpenMeld skill link found; update required"
+		});
+		return createStateResult({
+			base,
+			source,
+			state: "external_conflict",
+			reason: "existing non-OpenMeld skill detected; skipped to avoid overwrite"
+		});
+	}
+	if (!target.isSymlink && target.marker.contentHash) {
+		if (!(await lstat(join(base.skillDir, "SKILL.md")).catch(() => null))?.isFile()) return createStateResult({
+			base,
+			source,
+			state: "outdated",
+			targetMarker: target.marker,
+			reason: "OpenMeld Skill entry is missing"
+		});
+		if (await computeDirectoryContentHash({
+			rootDir: base.skillDir,
+			ignoredNames: [".openmeld-skill.json"]
+		}) !== target.marker.contentHash) return createStateResult({
+			base,
+			source,
+			state: "external_conflict",
+			targetMarker: target.marker,
+			reason: "OpenMeld Skill files were modified locally; kept your changes"
+		});
+	}
+	if (isUpToDate({
+		source,
+		targetMarker: target.marker,
+		isSymlink: target.isSymlink,
+		symlinkTargetPath: target.symlinkTargetPath,
+		sourceSkillDir: input.skill.absolutePath
+	})) return createStateResult({
+		base,
+		source,
+		targetMarker: target.marker,
+		state: "up_to_date",
+		reason: "already up-to-date"
+	});
+	return createStateResult({
+		base,
+		source,
+		targetMarker: target.marker,
+		state: "outdated",
+		reason: target.isSymlink ? "OpenMeld skill link points to a different OpenMeld skills store; update required" : "OpenMeld skill content changed; update required"
+	});
+}
+function createBaseResult(input) {
+	const skillDir = join(input.target.dir, input.skill.id);
+	return {
+		targetId: input.target.id,
+		targetDir: input.target.dir,
+		targetType: input.target.type,
+		skillId: input.skill.id,
+		skillDir
+	};
+}
+async function resolveSourceSnapshot(skill) {
+	const sourceMarker = await readOpenMeldSkillMarker(skill.absolutePath);
+	return {
+		...skill.contentHash ?? sourceMarker?.contentHash ? { hash: skill.contentHash ?? sourceMarker?.contentHash } : {},
+		...skill.version ?? sourceMarker?.version ? { version: skill.version ?? sourceMarker?.version } : {}
+	};
+}
+async function resolveTargetSnapshot(skillDir) {
+	const stats = await lstat(skillDir).catch(() => null);
+	if (!stats) return { exists: false };
+	let marker = await readOpenMeldSkillMarker(skillDir);
+	let symlinkTargetPath = "";
+	if (stats.isSymbolicLink()) {
+		symlinkTargetPath = await resolveSymlinkTarget(skillDir).catch(() => "");
+		if (!marker && symlinkTargetPath) marker = await readOpenMeldSkillMarker(symlinkTargetPath);
+	}
+	return {
+		exists: true,
+		isSymlink: stats.isSymbolicLink(),
+		marker,
+		symlinkTargetPath,
+		destinationExists: symlinkTargetPath ? Boolean(await lstat(symlinkTargetPath).catch(() => null)) : true
+	};
+}
+function isLegacyOpenMeldSkillSymlink(input) {
+	if (!(input.target.isSymlink && input.target.symlinkTargetPath) || input.target.destinationExists) return false;
+	return basename(input.target.symlinkTargetPath) === input.skillId;
+}
+function isUpToDate(input) {
+	if (input.isSymlink) return input.symlinkTargetPath.length > 0 && pathsEqual(input.symlinkTargetPath, input.sourceSkillDir);
+	return hasMatchingHashAndVersion(input.source, input.targetMarker);
+}
+function hasMatchingHashAndVersion(source, targetMarker) {
+	if (!(source.hash && targetMarker.contentHash && source.hash === targetMarker.contentHash)) return false;
+	return !(source.version && targetMarker.version) || source.version === targetMarker.version;
+}
+function createStateResult(input) {
+	return {
+		...input.base,
+		state: input.state,
+		...input.source.hash ? { sourceHash: input.source.hash } : {},
+		...input.source.version ? { sourceVersion: input.source.version } : {},
+		...input.targetMarker?.contentHash ? { targetHash: input.targetMarker.contentHash } : {},
+		...input.targetMarker?.mode ? { targetMode: input.targetMarker.mode } : {},
+		...input.targetMode ? { targetMode: input.targetMode } : {},
+		...input.targetMarker?.version ? { targetVersion: input.targetMarker.version } : {},
+		...input.reason ? { reason: input.reason } : {}
+	};
+}
+async function resolveSymlinkTarget(linkPath) {
+	const target = await readlink(linkPath);
+	return resolve(dirname(linkPath), target);
+}
+function pathsEqual(left, right) {
+	return resolve(left) === resolve(right);
+}
+//#endregion
+//#region src/skills/installation-inventory.ts
+async function collectSkillsReadinessSnapshot() {
+	const skillsConfig = await getConfiguredSkillsConfig();
+	const registry = resolveSkillsAgentRegistry(skillsConfig);
+	const installedAgents = await detectInstalledSkillsAgents(registry);
+	const localSkills = await ensureLocalSkills();
+	const checkTargets = mergeTargetsByDir({
+		primary: buildAgentTargets(installedAgents, registry),
+		secondary: await resolveTrackedInstallTargets({
+			skillsConfig,
+			registry,
+			localSkills,
+			onlyOpenMeldInstalledTargets: false
+		})
+	});
+	const states = await resolveSkillsInstallStates({
+		skills: localSkills,
+		targets: checkTargets
+	});
+	await persistDetectedInstallStateFromCheck({ states });
+	const summary = summarizeSkillState(states);
+	const hasIssues = summary.outdated > 0 || summary.missing > 0 || summary.externalConflict > 0;
+	let status = "up_to_date";
+	if (checkTargets.length === 0) status = "no_targets";
+	else if (hasIssues) status = "action_required";
+	return {
+		status,
+		targetCount: checkTargets.length,
+		summary
+	};
+}
+function buildAgentTargets(agents, registry) {
+	return agents.flatMap((agentName) => {
+		const config = registry[agentName];
+		if (!config?.globalSkillsDir || config.skillsInstallable !== true) return [];
+		return [{
+			id: agentName,
+			dir: config.globalSkillsDir,
+			type: "agent"
+		}];
+	});
+}
+function isLikelyCustomTargetId(value) {
+	return value.startsWith("custom-");
+}
+function resolveTrackedInstallTargets(input) {
+	const installs = input.skillsConfig?.installs ?? [];
+	const customTargetByDir = buildCustomTargetByDir(input.skillsConfig?.customTargets ?? []);
+	const byTargetDir = /* @__PURE__ */ new Map();
+	seedTrackedTargetsFromCustomTargets({
+		byTargetDir,
+		customTargetByDir
+	});
+	seedTrackedTargetsFromInstallRecords({
+		byTargetDir,
+		installs,
+		registry: input.registry,
+		customTargetByDir
+	});
+	const candidates = sortTrackedTargets([...byTargetDir.values()]);
+	return filterTrackedTargetsByState({
+		candidates: canManageRegistryAgentSkillTargets() ? candidates : candidates.filter((target) => target.type === "custom" || input.registry[target.id]?.globalSkillsDirSource === "config-override"),
+		localSkills: input.localSkills,
+		onlyOpenMeldInstalledTargets: input.onlyOpenMeldInstalledTargets
+	});
+}
+function buildCustomTargetByDir(customTargets) {
+	const customTargetByDir = /* @__PURE__ */ new Map();
+	for (const customTarget of customTargets) {
+		const id = resolveRuntimeSkillsCustomTargetId({
+			dir: customTarget.dir,
+			...customTarget.id ? { id: customTarget.id } : {}
+		});
+		customTargetByDir.set(customTarget.dir, {
+			id,
+			name: customTarget.name,
+			dir: customTarget.dir
+		});
+	}
+	return customTargetByDir;
+}
+function seedTrackedTargetsFromCustomTargets(input) {
+	for (const customTarget of input.customTargetByDir.values()) input.byTargetDir.set(customTarget.dir, {
+		id: customTarget.id ?? resolveRuntimeSkillsCustomTargetId({ dir: customTarget.dir }),
+		dir: customTarget.dir,
+		type: "custom"
+	});
+}
+function seedTrackedTargetsFromInstallRecords(input) {
+	for (const install of input.installs) {
+		const trackedTarget = buildTrackedTargetFromInstallRecord({
+			install,
+			registry: input.registry,
+			customTargetByDir: input.customTargetByDir
+		});
+		input.byTargetDir.set(install.targetDir, trackedTarget);
+	}
+}
+function buildTrackedTargetFromInstallRecord(input) {
+	const knownAgentDir = input.registry[input.install.targetId]?.globalSkillsDir;
+	if ((knownAgentDir && knownAgentDir === input.install.targetDir ? "agent" : "custom") === "agent") return {
+		id: input.install.targetId,
+		dir: input.install.targetDir,
+		type: "agent"
+	};
+	const customTarget = input.customTargetByDir.get(input.install.targetDir);
+	const fallbackCustomId = isLikelyCustomTargetId(input.install.targetId) ? input.install.targetId : void 0;
+	const resolvedCustomId = customTarget?.id ?? fallbackCustomId;
+	return {
+		id: resolveRuntimeSkillsCustomTargetId({
+			dir: input.install.targetDir,
+			...resolvedCustomId ? { id: resolvedCustomId } : {}
+		}),
+		dir: input.install.targetDir,
+		type: "custom"
+	};
+}
+function sortTrackedTargets(targets) {
+	return [...targets].sort((a, b) => `${a.id}:${a.dir}`.localeCompare(`${b.id}:${b.dir}`));
+}
+function mergeTargetsByDir(input) {
+	const byDir = /* @__PURE__ */ new Map();
+	for (const target of input.secondary) byDir.set(target.dir, target);
+	for (const target of input.primary) byDir.set(target.dir, target);
+	return sortTrackedTargets([...byDir.values()]);
+}
+async function filterInstalledTrackedTargets(input) {
+	const installedOnly = [];
+	for (const candidate of input.candidates) {
+		if (!await targetHasInstalledOpenMeldSkill({
+			target: candidate,
+			localSkills: input.localSkills
+		})) continue;
+		installedOnly.push(candidate);
+	}
+	return installedOnly;
+}
+async function filterTargetsWithInstalledOpenMeldSkills(input) {
+	return filterInstalledTrackedTargets({
+		candidates: await filterExistingTargetDirs(input.targets),
+		localSkills: input.localSkills
+	});
+}
+async function filterTrackedTargetsByState(input) {
+	const existingTargets = await filterExistingTargetDirs(input.candidates);
+	if (!input.onlyOpenMeldInstalledTargets) return existingTargets;
+	return filterInstalledTrackedTargets({
+		candidates: existingTargets,
+		localSkills: input.localSkills
+	});
+}
+async function filterExistingTargetDirs(candidates) {
+	const existing = [];
+	for (const candidate of candidates) {
+		if (!(await stat(candidate.dir).catch(() => null))?.isDirectory()) continue;
+		existing.push(candidate);
+	}
+	return existing;
+}
+function summarizeSkillState(states) {
+	return {
+		upToDate: states.filter((state) => state.state === "up_to_date").length,
+		outdated: states.filter((state) => state.state === "outdated").length,
+		missing: states.filter((state) => state.state === "missing").length,
+		externalConflict: states.filter((state) => state.state === "external_conflict").length
+	};
+}
+async function targetHasInstalledOpenMeldSkill(input) {
+	if (!(await stat(input.target.dir).catch(() => null))?.isDirectory()) return false;
+	for (const skill of input.localSkills) {
+		const state = await resolveSkillInstallStateForTarget({
+			skill,
+			target: input.target
+		});
+		if (state.state === "up_to_date" || state.state === "outdated") return true;
+	}
+	return false;
+}
+async function persistDetectedInstallStateFromCheck(input) {
+	const discoveredByTargetDir = /* @__PURE__ */ new Map();
+	for (const state of input.states) {
+		if (!(state.state === "up_to_date" || state.state === "outdated")) continue;
+		const list = discoveredByTargetDir.get(state.targetDir) ?? [];
+		list.push(state);
+		discoveredByTargetDir.set(state.targetDir, list);
+	}
+	if (discoveredByTargetDir.size === 0) return;
+	await updateConfiguredSkillsConfig((currentSkillsConfig) => {
+		const byTargetDir = /* @__PURE__ */ new Map();
+		for (const record of currentSkillsConfig?.installs ?? []) byTargetDir.set(record.targetDir, record);
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		for (const [targetDir, group] of discoveredByTargetDir) {
+			const first = group[0];
+			if (!first) continue;
+			const mode = group.some((state) => state.targetMode === "copy") ? "copy" : "symlink";
+			const skillIds = Array.from(new Set(group.map((state) => state.skillId))).sort((a, b) => a.localeCompare(b));
+			byTargetDir.set(targetDir, {
+				targetId: first.targetId,
+				targetDir,
+				mode,
+				status: "installed",
+				skillIds,
+				updatedAt: now
+			});
+		}
+		const nextInstalls = [...byTargetDir.values()].sort(compareInstallRecords);
+		const previousInstalls = [...currentSkillsConfig?.installs ?? []].sort(compareInstallRecords).map(normalizeInstallRecordForCompare);
+		const nextComparable = nextInstalls.map(normalizeInstallRecordForCompare);
+		if (JSON.stringify(previousInstalls) === JSON.stringify(nextComparable)) return currentSkillsConfig;
+		return {
+			storeDir: currentSkillsConfig?.storeDir ?? skillsDir(),
+			...currentSkillsConfig?.agents ? { agents: currentSkillsConfig.agents } : {},
+			...currentSkillsConfig?.customTargets ? { customTargets: currentSkillsConfig.customTargets } : {},
+			installs: nextInstalls
+		};
+	});
+}
+function compareInstallRecords(left, right) {
+	const byTargetId = left.targetId.localeCompare(right.targetId);
+	if (byTargetId !== 0) return byTargetId;
+	return left.targetDir.localeCompare(right.targetDir);
+}
+function normalizeInstallRecordForCompare(input) {
+	return {
+		targetId: input.targetId,
+		targetDir: input.targetDir,
+		mode: input.mode,
+		status: input.status,
+		skillIds: [...input.skillIds].sort((a, b) => a.localeCompare(b)),
+		...input.reason ? { reason: input.reason } : {}
+	};
+}
+//#endregion
+//#region src/skills/installer.ts
+function installSkillsToTargets(input) {
+	return withSkillsInstallLock(() => installSkillsToTargetsLocked(input));
+}
+async function installSkillsToTargetsLocked(input) {
+	const results = [];
+	for (const target of input.targets) for (const skill of input.skills) {
+		const result = await installOneSkillToTarget({
+			skill,
+			target
+		});
+		results.push(result);
+	}
+	return results;
+}
+async function installOneSkillToTarget(input) {
+	const targetDir = input.target.dir;
+	const failInstall = (reason) => ({
+		targetId: input.target.id,
+		targetDir,
+		targetType: input.target.type,
+		skillId: input.skill.id,
+		status: "failed",
+		mode: "unknown",
+		degraded: false,
+		reason
+	});
+	if (!isAbsolute(targetDir)) return failInstall("target dir must be an absolute path");
+	const skillId = input.skill.id;
+	if (skillId.trim().length === 0 || isAbsolute(skillId) || skillId === "." || skillId === ".." || skillId.includes("/") || skillId.includes("\\")) return failInstall("skill id would escape target dir");
+	const resolvedTargetDir = resolve(targetDir);
+	const resolvedSkillDir = resolve(resolvedTargetDir, skillId);
+	const skillRelativePath = relative(resolvedTargetDir, resolvedSkillDir);
+	if (skillRelativePath === ".." || skillRelativePath.startsWith("../") || skillRelativePath.startsWith("..\\")) return failInstall("skill id would escape target dir");
+	const skillTargetDir = resolvedSkillDir;
+	await mkdir(targetDir, { recursive: true });
+	await recoverSkillReplacement(skillTargetDir);
+	const state = await resolveSkillInstallStateForTarget({
+		skill: input.skill,
+		target: input.target
+	});
+	if (state.state === "external_conflict") return {
+		targetId: input.target.id,
+		targetDir,
+		targetType: input.target.type,
+		skillId: input.skill.id,
+		status: "skipped",
+		mode: resolveSkippedInstallMode(state),
+		degraded: false,
+		reason: state.reason
+	};
+	if (state.state === "up_to_date") return {
+		targetId: input.target.id,
+		targetDir,
+		targetType: input.target.type,
+		skillId: input.skill.id,
+		status: "skipped",
+		mode: resolveSkippedInstallMode(state),
+		degraded: false,
+		reason: state.reason
+	};
+	const installation = { mode: "symlink" };
+	try {
+		await readFile(join(input.skill.absolutePath, "SKILL.md"), "utf8");
+		await replaceSkillDirectory(skillTargetDir, async (stagedDir) => {
+			if (await tryCreateSymlink({
+				sourceDir: input.skill.absolutePath,
+				targetDir: stagedDir
+			})) return;
+			installation.mode = "copy";
+			await cp(input.skill.absolutePath, stagedDir, {
+				recursive: true,
+				errorOnExist: true,
+				force: false
+			});
+			await writeOpenMeldSkillMarker({
+				skillDir: stagedDir,
+				skillId: input.skill.id,
+				mode: "copy",
+				...input.skill.contentHash ? { contentHash: input.skill.contentHash } : {},
+				...input.skill.version ? { version: input.skill.version } : {}
+			});
+		});
+		return {
+			targetId: input.target.id,
+			targetDir,
+			targetType: input.target.type,
+			skillId: input.skill.id,
+			status: "installed",
+			mode: installation.mode,
+			degraded: installation.mode === "copy",
+			...installation.mode === "copy" ? { reason: "symlink failed; fell back to copy" } : {}
+		};
+	} catch (error) {
+		return failInstall(error instanceof Error ? error.message : "failed to install skill to target");
+	}
+}
+function resolveSkippedInstallMode(state) {
+	if (state.targetMode === "copy") return "copy";
+	if (state.targetMode === "symlink") return "symlink";
+	return "unknown";
+}
+async function tryCreateSymlink(input) {
+	try {
+		await mkdir(dirname(input.targetDir), { recursive: true });
+		const targetParentDir = dirname(input.targetDir);
+		const resolvedTargetParentDir = await realpath(targetParentDir).catch(() => targetParentDir);
+		const resolvedSourceDir = await realpath(input.sourceDir).catch(() => input.sourceDir);
+		const relativeTarget = relative(resolvedTargetParentDir, resolvedSourceDir);
+		await symlink(process$1.platform === "win32" ? resolvedSourceDir : relativeTarget, input.targetDir, process$1.platform === "win32" ? "junction" : void 0);
+		return true;
+	} catch {
+		return false;
+	}
+}
+//#endregion
+export { readSelectedSkillDocument as _, filterTargetsWithInstalledOpenMeldSkills as a, computeDirectoryContentHash as b, resolveTrackedInstallTargets as c, resolveSkillsInstallStates as d, ensureLocalSkills as f, loadSelectedSkillAssets as g, downloadOfficialSkillUpdate as h, compareInstallRecords as i, summarizeSkillState as l, readOpenMeldSkillMarker as m, buildAgentTargets as n, mergeTargetsByDir as o, isOpenMeldManagedSkillDir as p, collectSkillsReadinessSnapshot as r, persistDetectedInstallStateFromCheck as s, installSkillsToTargets as t, resolveSkillInstallStateForTarget as u, withSkillsInstallLock as v, OFFICIAL_CLI_SKILL_URL as x, hashBundledSkillAssets as y };
+
+//# sourceMappingURL=installer-CLPF4DHx.js.map