@sentry/junior 0.202.0 → 0.204.0

package/dist/oauth-callback-server-JiftokvA.js

@@ -0,0 +1,130 @@
+import { Q as createUserTokenStore } from "./agent-CMyTD4DD.js";
+import { a as GET, n as syncLocalOAuthCredential, r as GET$1 } from "./credential-sync-kXr1hvO1.js";
+import { createServer } from "node:http";
+//#region src/chat/local/oauth-callback-server.ts
+const LOCAL_OAUTH_TIMEOUT_MS = 6e5;
+const LOCAL_OAUTH_CALLBACK_TIMEOUT_MS = 6e4;
+function decodeProvider(value) {
+	if (!value) return;
+	try {
+		const provider = decodeURIComponent(value);
+		return /^[a-z][a-z0-9-]*$/.test(provider) ? provider : void 0;
+	} catch {
+		return;
+	}
+}
+/** Start the loopback callback that completes OAuth in the local CLI process. */
+async function startLocalOAuthCallbackServer(agentRunner) {
+	let pendingAuthorization;
+	const completeAuthorization = (authorization, result) => {
+		if (authorization.settled) return;
+		authorization.settled = true;
+		clearTimeout(authorization.timeout);
+		authorization.finish(result);
+	};
+	const cancelAuthorization = () => {
+		const authorization = pendingAuthorization;
+		if (!authorization) return;
+		pendingAuthorization = void 0;
+		completeAuthorization(authorization, /* @__PURE__ */ new Error("Local OAuth authorization canceled"));
+	};
+	const server = createServer(async (incoming, outgoing) => {
+		const host = incoming.headers.host ?? "127.0.0.1";
+		let requestUrl;
+		try {
+			requestUrl = new URL(incoming.url ?? "/", `http://${host}`);
+		} catch {
+			outgoing.writeHead(400).end("Invalid callback request");
+			return;
+		}
+		const mcpMatch = requestUrl.pathname.match(/^\/api\/oauth\/callback\/mcp\/([^/]+)$/);
+		const pluginMatch = requestUrl.pathname.match(/^\/api\/oauth\/callback\/([^/]+)$/);
+		const provider = decodeProvider(mcpMatch?.[1] ?? pluginMatch?.[1]);
+		if (!provider) {
+			outgoing.writeHead(404).end("Not found");
+			return;
+		}
+		const authorization = pendingAuthorization;
+		if (!authorization || authorization.callbackStarted || authorization.settled || requestUrl.searchParams.get("state") !== authorization.state) {
+			outgoing.writeHead(409).end("No matching authorization request");
+			return;
+		}
+		authorization.callbackStarted = true;
+		clearTimeout(authorization.timeout);
+		authorization.timeout = setTimeout(() => {
+			if (!outgoing.headersSent) outgoing.writeHead(504).end("Authorization callback timed out");
+			completeAuthorization(authorization, /* @__PURE__ */ new Error("Timed out completing OAuth authorization"));
+		}, LOCAL_OAUTH_CALLBACK_TIMEOUT_MS);
+		const backgroundTasks = [];
+		const waitUntil = (task) => {
+			backgroundTasks.push(typeof task === "function" ? Promise.resolve().then(task) : task);
+		};
+		try {
+			const request = new Request(requestUrl, { method: "GET" });
+			const response = mcpMatch ? await GET(request, provider, waitUntil, { agentRunner }) : await GET$1(request, provider, waitUntil, { agentRunner });
+			const body = Buffer.from(await response.arrayBuffer());
+			await Promise.all(backgroundTasks);
+			if (response.ok) {
+				if (!mcpMatch) {
+					const tokens = await createUserTokenStore().get("local-cli", provider);
+					if (!tokens) throw new Error(`${provider} authorization completed without a stored credential`);
+					await syncLocalOAuthCredential(provider, tokens);
+				}
+			}
+			if (authorization.settled) return;
+			if (response.ok) completeAuthorization(authorization, true);
+			else completeAuthorization(authorization, /* @__PURE__ */ new Error(`${provider} authorization callback failed with HTTP ${response.status}`));
+			outgoing.writeHead(response.status, Object.fromEntries(response.headers.entries()));
+			outgoing.end(body);
+		} catch (error) {
+			if (!outgoing.headersSent) outgoing.writeHead(500).end("Authorization callback failed");
+			completeAuthorization(authorization, error instanceof Error ? error : new Error(String(error)));
+		}
+	});
+	await new Promise((resolve, reject) => {
+		server.once("error", reject);
+		server.listen(0, "127.0.0.1", () => {
+			server.off("error", reject);
+			resolve();
+		});
+	});
+	return {
+		beginAuthorization: (authorizationUrl) => {
+			if (pendingAuthorization) throw new Error("Local OAuth already has an active authorization");
+			const state = new URL(authorizationUrl).searchParams.get("state");
+			if (!state) throw new Error("Local OAuth authorization URL is missing state");
+			let finish = () => void 0;
+			const result = new Promise((resolve) => {
+				finish = resolve;
+			});
+			const authorization = {
+				callbackStarted: false,
+				finish,
+				result,
+				settled: false,
+				state,
+				timeout: setTimeout(() => {
+					completeAuthorization(authorization, /* @__PURE__ */ new Error("Timed out waiting for OAuth authorization"));
+				}, LOCAL_OAUTH_TIMEOUT_MS)
+			};
+			pendingAuthorization = authorization;
+		},
+		cancelAuthorization,
+		port: server.address().port,
+		waitForAuthorization: async () => {
+			const authorization = pendingAuthorization;
+			if (!authorization) throw new Error("Local OAuth has no active authorization");
+			const result = await authorization.result;
+			if (pendingAuthorization === authorization) pendingAuthorization = void 0;
+			if (result instanceof Error) throw result;
+		},
+		close: async () => {
+			cancelAuthorization();
+			await new Promise((resolve, reject) => {
+				server.close((error) => error ? reject(error) : resolve());
+			});
+		}
+	};
+}
+//#endregion
+export { startLocalOAuthCallbackServer };

package/dist/oauth-relay-CdCnu80W.js

@@ -0,0 +1,62 @@
+import { t as __exportAll } from "./rolldown-runtime-B4FMCO8f.js";
+import { z } from "zod";
+import { randomBytes } from "node:crypto";
+import { SignJWT, jwtVerify } from "jose";
+//#region src/chat/local/oauth-relay.ts
+var oauth_relay_exports = /* @__PURE__ */ __exportAll({
+	createLocalOAuthState: () => createLocalOAuthState,
+	relayLocalOAuthCallback: () => relayLocalOAuthCallback
+});
+const LOCAL_OAUTH_STATE_PREFIX = "jr-local";
+const LOCAL_OAUTH_TOKEN_CONTEXT = "junior.local-oauth-relay.v1";
+const LOCAL_OAUTH_TOKEN_TTL = "10m";
+const localOAuthRelayPayloadSchema = z.object({
+	aud: z.literal(LOCAL_OAUTH_TOKEN_CONTEXT),
+	exp: z.number().int(),
+	iss: z.literal(LOCAL_OAUTH_TOKEN_CONTEXT),
+	jti: z.string().min(1),
+	port: z.number().int().min(1).max(65535)
+}).strict();
+/** Derive the HMAC key used only for signed local OAuth relay state. */
+function relayKey() {
+	const secret = process.env.JUNIOR_SECRET?.trim();
+	if (!secret) throw new Error("Local OAuth requires JUNIOR_SECRET");
+	return new TextEncoder().encode(secret);
+}
+/** Create an OAuth state value that can be safely relayed to a local CLI callback. */
+async function createLocalOAuthState(port) {
+	if (!Number.isSafeInteger(port) || port < 1 || port > 65535) throw new Error("Local OAuth callback port is invalid");
+	const token = await new SignJWT({ port }).setProtectedHeader({ alg: "HS256" }).setIssuer(LOCAL_OAUTH_TOKEN_CONTEXT).setAudience(LOCAL_OAUTH_TOKEN_CONTEXT).setJti(randomBytes(24).toString("base64url")).setExpirationTime(LOCAL_OAUTH_TOKEN_TTL).sign(relayKey());
+	return `${LOCAL_OAUTH_STATE_PREFIX}.${token}`;
+}
+/** Resolve a signed local OAuth state to its loopback callback port. */
+async function localOAuthRelayPort(state) {
+	const prefix = `${LOCAL_OAUTH_STATE_PREFIX}.`;
+	if (!state.startsWith(prefix)) return;
+	try {
+		const { payload } = await jwtVerify(state.slice(prefix.length), relayKey(), {
+			algorithms: ["HS256"],
+			issuer: LOCAL_OAUTH_TOKEN_CONTEXT,
+			audience: LOCAL_OAUTH_TOKEN_CONTEXT
+		});
+		const parsed = localOAuthRelayPayloadSchema.safeParse(payload);
+		return parsed.success ? parsed.data.port : void 0;
+	} catch {
+		return;
+	}
+}
+/** Redirect a provider callback from the public dev URL to the owning local CLI. */
+async function relayLocalOAuthCallback(request) {
+	const url = new URL(request.url);
+	if (url.searchParams.get("jr_local_relay") === "complete") return;
+	const state = url.searchParams.get("state");
+	const port = state ? await localOAuthRelayPort(state) : void 0;
+	if (!port) return;
+	url.protocol = "http:";
+	url.hostname = "127.0.0.1";
+	url.port = String(port);
+	url.searchParams.set("jr_local_relay", "complete");
+	return Response.redirect(url, 302);
+}
+//#endregion
+export { relayLocalOAuthCallback as n, oauth_relay_exports as t };

package/dist/package-discovery-7a9YqLhE.js

@@ -0,0 +1,455 @@
+import { t as __exportAll } from "./rolldown-runtime-B4FMCO8f.js";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+import path from "node:path";
+import fs, { statSync } from "node:fs";
+//#region src/package-resolution.ts
+function isDirectory$1(targetPath) {
+	try {
+		return statSync(targetPath).isDirectory();
+	} catch {
+		return false;
+	}
+}
+function isFile$1(targetPath) {
+	try {
+		return statSync(targetPath).isFile();
+	} catch {
+		return false;
+	}
+}
+function uniqueResolvedPathsInOrder$1(values) {
+	const seen = /* @__PURE__ */ new Set();
+	const resolved = [];
+	for (const value of values) {
+		const normalized = path.resolve(value);
+		if (seen.has(normalized)) continue;
+		seen.add(normalized);
+		resolved.push(normalized);
+	}
+	return resolved;
+}
+function ancestorNodeModulesDirs(cwd) {
+	const dirs = [];
+	let current = path.resolve(cwd);
+	while (true) {
+		const nodeModulesDir = path.join(current, "node_modules");
+		if (isDirectory$1(nodeModulesDir)) dirs.push(nodeModulesDir);
+		const parent = path.dirname(current);
+		if (parent === current) break;
+		current = parent;
+	}
+	return dirs;
+}
+function packageDirInNodeModules(nodeModulesDir, packageName) {
+	const packageDir = path.join(nodeModulesDir, ...packageName.split("/"));
+	return isDirectory$1(packageDir) ? path.resolve(packageDir) : void 0;
+}
+function isValidPackageSegment(segment) {
+	return Boolean(segment) && segment !== "." && segment !== ".." && !segment.startsWith(".") && /^[A-Za-z0-9._~-]+$/.test(segment);
+}
+/** Return whether a string is shaped like an npm package name. */
+function isValidPackageName(packageName) {
+	if (!packageName || packageName.includes("\\") || path.isAbsolute(packageName)) return false;
+	const parts = packageName.split("/");
+	if (parts[0].startsWith("@")) return parts.length === 2 && parts[0].length > 1 && isValidPackageSegment(parts[0].slice(1)) && isValidPackageSegment(parts[1]);
+	return parts.length === 1 && isValidPackageSegment(parts[0]);
+}
+function findPackageRoot(entryPath) {
+	let dir = path.dirname(entryPath);
+	while (dir !== path.dirname(dir)) {
+		if (isFile$1(path.join(dir, "package.json"))) return path.resolve(dir);
+		dir = path.dirname(dir);
+	}
+}
+function findPackageNodeModulesDir(packageDir, packageName) {
+	const parts = path.resolve(packageDir).split(path.sep);
+	const packageParts = packageName.split("/");
+	for (let index = parts.length - 1; index >= 0; index -= 1) {
+		if (parts[index] !== "node_modules") continue;
+		if (parts.slice(index + 1, index + 1 + packageParts.length).join("/") !== packageParts.join("/")) continue;
+		return path.resolve(parts.slice(0, index + 1).join(path.sep) || path.sep);
+	}
+}
+function resolvePackageWithNode(cwd, packageName) {
+	let requireFromCwd;
+	try {
+		requireFromCwd = createRequire(path.join(cwd, "package.json"));
+	} catch {
+		return;
+	}
+	for (const specifier of [`${packageName}/package.json`, packageName]) try {
+		const resolved = requireFromCwd.resolve(specifier);
+		const dir = specifier.endsWith("/package.json") ? path.dirname(resolved) : findPackageRoot(resolved);
+		if (!dir) continue;
+		const nodeModulesDir = findPackageNodeModulesDir(dir, packageName);
+		return {
+			dir,
+			...nodeModulesDir ? { nodeModulesDir } : void 0
+		};
+	} catch {}
+}
+/** Resolve a package root from an app cwd without requiring the package to expose a JS entry point. */
+function resolvePackageLocation(cwd, packageName, options) {
+	if (!isValidPackageName(packageName)) return;
+	const nodeModulesDirs = uniqueResolvedPathsInOrder$1([...options?.nodeModulesDirs ?? [], ...ancestorNodeModulesDirs(cwd)]);
+	for (const nodeModulesDir of nodeModulesDirs) {
+		const dir = packageDirInNodeModules(nodeModulesDir, packageName);
+		if (dir) return {
+			dir,
+			nodeModulesDir
+		};
+	}
+	return resolvePackageWithNode(cwd, packageName);
+}
+/** Resolve a package root directory from an app cwd. */
+function resolvePackageDir(cwd, packageName) {
+	return resolvePackageLocation(cwd, packageName)?.dir;
+}
+//#endregion
+//#region src/chat/discovery.ts
+var discovery_exports = /* @__PURE__ */ __exportAll({
+	builtInSkillsDir: () => builtInSkillsDir,
+	dataDir: () => dataDir,
+	dataRoots: () => dataRoots,
+	descriptionPath: () => descriptionPath,
+	descriptionPathCandidates: () => descriptionPathCandidates,
+	discoverNodeModulesDirs: () => discoverNodeModulesDirs,
+	discoverProjectRoots: () => discoverProjectRoots,
+	homeDir: () => homeDir,
+	isDirectory: () => isDirectory,
+	isFile: () => isFile,
+	listReferenceFiles: () => listReferenceFiles,
+	pluginRoots: () => pluginRoots,
+	pluginsDir: () => pluginsDir,
+	resolveHomeDir: () => resolveHomeDir,
+	skillRoots: () => skillRoots,
+	skillsDir: () => skillsDir,
+	soulPath: () => soulPath,
+	soulPathCandidates: () => soulPathCandidates,
+	worldPath: () => worldPath,
+	worldPathCandidates: () => worldPathCandidates
+});
+/** Check whether a path exists and is a directory. */
+function isDirectory(targetPath) {
+	try {
+		return statSync(targetPath).isDirectory();
+	} catch {
+		return false;
+	}
+}
+/** Check whether a path exists and is a regular file. */
+function isFile(targetPath) {
+	try {
+		return statSync(targetPath).isFile();
+	} catch {
+		return false;
+	}
+}
+function normalizePath(targetPath) {
+	return path.resolve(targetPath);
+}
+function uniqueResolvedPathsInOrder(values) {
+	const seen = /* @__PURE__ */ new Set();
+	const resolved = [];
+	for (const value of values) {
+		const normalized = normalizePath(value);
+		if (seen.has(normalized)) continue;
+		seen.add(normalized);
+		resolved.push(normalized);
+	}
+	return resolved;
+}
+function isNodeModulesPath(candidatePath) {
+	return path.basename(candidatePath) === "node_modules";
+}
+function isInsidePnpmStore(candidatePath) {
+	return candidatePath.split(path.sep).includes(".pnpm");
+}
+function runningFromInstalledPackage() {
+	const currentFile = fileURLToPath(import.meta.url);
+	const marker = `${path.sep}node_modules${path.sep}@sentry${path.sep}junior${path.sep}`;
+	return currentFile.includes(marker);
+}
+function listInstalledPackageNodeModulesDirs() {
+	if (!runningFromInstalledPackage()) return [];
+	const dirs = [];
+	let current = path.resolve(path.dirname(fileURLToPath(import.meta.url)));
+	while (true) {
+		if (isNodeModulesPath(current) && !isInsidePnpmStore(current) && isDirectory(current)) dirs.push(current);
+		const parent = path.dirname(current);
+		if (parent === current) break;
+		current = parent;
+	}
+	return dirs;
+}
+function listCwdAncestorNodeModulesDirs(cwd) {
+	const resolvedCwd = normalizePath(cwd);
+	const dirs = [];
+	let current = resolvedCwd;
+	while (true) {
+		const nodeModulesDir = path.join(current, "node_modules");
+		if (isDirectory(nodeModulesDir)) dirs.push(nodeModulesDir);
+		if (isFile(path.join(current, "package.json"))) break;
+		const parent = path.dirname(current);
+		if (parent === current) break;
+		current = parent;
+	}
+	return dirs;
+}
+/** Discover node_modules directories reachable from the current working directory. */
+function discoverNodeModulesDirs(cwd = process.cwd(), options) {
+	const explicit = options?.candidateDirs?.filter((dir) => isDirectory(dir)) ?? [];
+	if (explicit.length > 0) return uniqueResolvedPathsInOrder(explicit);
+	return uniqueResolvedPathsInOrder([...listInstalledPackageNodeModulesDirs(), ...listCwdAncestorNodeModulesDirs(cwd)]);
+}
+/** Discover project root directories by walking up from cwd and checking node_modules parents. */
+function discoverProjectRoots(cwd = process.cwd(), options) {
+	return uniqueResolvedPathsInOrder([cwd, ...discoverNodeModulesDirs(cwd, options?.nodeModulesDirs ? { candidateDirs: options.nodeModulesDirs } : void 0).map((nodeModulesDir) => path.dirname(nodeModulesDir))]);
+}
+function unique(values) {
+	return [...new Set(values)];
+}
+function pathExists(targetPath) {
+	try {
+		fs.accessSync(targetPath);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function hasAnyDataMarkers(appDir) {
+	return pathExists(path.join(appDir, "SOUL.md")) || pathExists(path.join(appDir, "WORLD.md"));
+}
+function scoreAppCandidate(appDir) {
+	let score = 0;
+	if (pathExists(path.join(appDir, "SOUL.md"))) score += 4;
+	if (pathExists(path.join(appDir, "WORLD.md"))) score += 2;
+	if (pathExists(path.join(appDir, "skills"))) score += 1;
+	if (pathExists(path.join(appDir, "plugins"))) score += 1;
+	return score;
+}
+function resolveCandidateAppDirs(cwd, projectRoots) {
+	const roots = projectRoots ?? discoverProjectRoots(cwd);
+	const resolved = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const root of roots) {
+		const appDir = path.resolve(root, "app");
+		if (!pathExists(appDir)) continue;
+		if (seen.has(appDir)) continue;
+		seen.add(appDir);
+		resolved.push(appDir);
+	}
+	return resolved;
+}
+/** Return the resolved app home directory for the current working directory. */
+function homeDir() {
+	return resolveHomeDir();
+}
+/** Resolve the app home directory by scoring candidate `app/` directories. */
+function resolveHomeDir(cwd = process.cwd(), options) {
+	const resolvedCwd = path.resolve(cwd);
+	const directApp = path.resolve(resolvedCwd, "app");
+	if (pathExists(directApp) && hasAnyDataMarkers(directApp)) return directApp;
+	const candidates = resolveCandidateAppDirs(resolvedCwd, options?.projectRoots);
+	if (candidates.length === 0) return directApp;
+	candidates.sort((left, right) => {
+		const leftScore = scoreAppCandidate(left);
+		const rightScore = scoreAppCandidate(right);
+		if (leftScore !== rightScore) return rightScore - leftScore;
+		const leftDistance = path.relative(resolvedCwd, left).split(path.sep).length;
+		const rightDistance = path.relative(resolvedCwd, right).split(path.sep).length;
+		if (leftDistance !== rightDistance) return leftDistance - rightDistance;
+		return left.localeCompare(right);
+	});
+	return candidates[0];
+}
+function resolveContentRoots(subdir) {
+	if (subdir === "data") return [homeDir()];
+	return [path.join(homeDir(), subdir)];
+}
+/** Return the built-in skills directory in source and packaged builds. */
+function builtInSkillsDir() {
+	const moduleDir = path.dirname(fileURLToPath(import.meta.url));
+	if (path.basename(moduleDir) === "dist") return path.join(path.dirname(moduleDir), "skills");
+	if (path.basename(moduleDir) === "chat" && path.basename(path.dirname(moduleDir)) === "src") return path.resolve(moduleDir, "../../skills");
+	const packageDir = resolvePackageDir(process.cwd(), "@sentry/junior");
+	return path.join(packageDir ?? moduleDir, "skills");
+}
+/** Return the data directory (same as homeDir). */
+function dataDir() {
+	return resolveContentRoots("data")[0];
+}
+/** Return the path to the SOUL.md file. */
+function soulPath() {
+	return path.join(dataDir(), "SOUL.md");
+}
+/** Return the path to the WORLD.md file. */
+function worldPath() {
+	return path.join(dataDir(), "WORLD.md");
+}
+/** Return the path to the DESCRIPTION.md file. */
+function descriptionPath() {
+	return path.join(dataDir(), "DESCRIPTION.md");
+}
+/** Return the skills directory path. */
+function skillsDir() {
+	return resolveContentRoots("skills")[0];
+}
+/** Return the plugins directory path. */
+function pluginsDir() {
+	return resolveContentRoots("plugins")[0];
+}
+/** Return all unique data root directories. */
+function dataRoots() {
+	return unique(resolveContentRoots("data"));
+}
+/** Return all unique skill root directories. */
+function skillRoots() {
+	return unique([builtInSkillsDir(), ...resolveContentRoots("skills")]);
+}
+/** Return all unique plugin root directories. */
+function pluginRoots() {
+	return unique(resolveContentRoots("plugins"));
+}
+/** Return candidate paths where SOUL.md might be found. */
+function soulPathCandidates() {
+	return unique(dataRoots().map((root) => path.join(root, "SOUL.md")));
+}
+/** Return candidate paths where WORLD.md might be found. */
+function worldPathCandidates() {
+	return unique(dataRoots().map((root) => path.join(root, "WORLD.md")));
+}
+/** Return candidate paths where DESCRIPTION.md might be found. */
+function descriptionPathCandidates() {
+	return unique(dataRoots().map((root) => path.join(root, "DESCRIPTION.md")));
+}
+const RESERVED_APP_FILES = /* @__PURE__ */ new Set([
+	"SOUL.md",
+	"WORLD.md",
+	"DESCRIPTION.md",
+	"ABOUT.md"
+]);
+/** List non-reserved .md files in the app root for sandbox reference syncing. */
+function listReferenceFiles() {
+	const appDir = homeDir();
+	try {
+		return fs.readdirSync(appDir, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".md") && !RESERVED_APP_FILES.has(entry.name)).map((entry) => path.join(appDir, entry.name)).sort();
+	} catch {
+		return [];
+	}
+}
+//#endregion
+//#region src/chat/plugins/package-discovery.ts
+function normalizeForGlob(targetPath) {
+	return targetPath.split(path.sep).join("/");
+}
+function uniqueStringsInOrder(values) {
+	const seen = /* @__PURE__ */ new Set();
+	const resolved = [];
+	for (const value of values) {
+		if (seen.has(value)) continue;
+		seen.add(value);
+		resolved.push(value);
+	}
+	return resolved;
+}
+function pathForTracingInclude(cwd, targetPath) {
+	const relative = path.relative(cwd, targetPath);
+	if (!relative || path.isAbsolute(relative) || relative === ".." || relative.startsWith(`..${path.sep}`)) return null;
+	const normalized = normalizeForGlob(relative);
+	return normalized.startsWith(".") ? normalized : `./${normalized}`;
+}
+/** Normalize and validate configured plugin package names. */
+function normalizePluginPackageNames(packageNames) {
+	if (packageNames === void 0) return [];
+	if (!Array.isArray(packageNames)) throw new Error("Plugin package names must be an array");
+	const normalized = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const packageName of packageNames) {
+		const normalizedPackageName = typeof packageName === "string" ? packageName.trim() : "";
+		if (!normalizedPackageName || !isValidPackageName(normalizedPackageName)) throw new Error("Plugin package names must be valid npm package names");
+		if (seen.has(normalizedPackageName)) continue;
+		seen.add(normalizedPackageName);
+		normalized.push(normalizedPackageName);
+	}
+	return normalized;
+}
+function formatNodeModulesDirs(candidateNodeModulesDirs) {
+	return candidateNodeModulesDirs.length > 0 ? candidateNodeModulesDirs.join(", ") : "none found";
+}
+function resolvePackageDirFromName(cwd, packageName, candidateNodeModulesDirs) {
+	return resolvePackageLocation(cwd, packageName, { nodeModulesDirs: candidateNodeModulesDirs }) ?? null;
+}
+function readPluginPackageFlags(dir) {
+	const hasRootPluginManifest = isFile(path.join(dir, "plugin.yaml"));
+	const hasMigrationsDir = isDirectory(path.join(dir, "migrations"));
+	const hasPluginsDir = isDirectory(path.join(dir, "plugins"));
+	const hasSkillsDir = isDirectory(path.join(dir, "skills"));
+	if (!hasRootPluginManifest && !hasMigrationsDir && !hasPluginsDir && !hasSkillsDir) return null;
+	return {
+		hasRootPluginManifest,
+		hasMigrationsDir,
+		hasPluginsDir,
+		hasSkillsDir
+	};
+}
+function discoverDeclaredPackages(packageNames, candidateNodeModulesDirs, cwd) {
+	const discovered = [];
+	const seenPackageDirs = /* @__PURE__ */ new Set();
+	for (const packageName of packageNames) {
+		const resolved = resolvePackageDirFromName(cwd, packageName, candidateNodeModulesDirs);
+		if (!resolved) throw new Error(`Plugin package "${packageName}" was configured but could not be resolved from node_modules or package resolution (${formatNodeModulesDirs(candidateNodeModulesDirs)})`);
+		if (seenPackageDirs.has(resolved.dir)) continue;
+		const pluginFlags = readPluginPackageFlags(resolved.dir);
+		if (!pluginFlags) throw new Error(`Plugin package "${packageName}" was configured but does not contain plugin content; expected plugin.yaml, migrations/, plugins/, or skills/ in ${resolved.dir}`);
+		seenPackageDirs.add(resolved.dir);
+		discovered.push({
+			dir: resolved.dir,
+			nodeModulesDir: resolved.nodeModulesDir,
+			packageName,
+			...pluginFlags
+		});
+	}
+	return discovered;
+}
+/** Discover plugin package content from explicitly declared package names. */
+function discoverInstalledPluginPackageContent(cwd = process.cwd(), options) {
+	const resolvedCwd = path.resolve(cwd);
+	const discoveredPackages = discoverDeclaredPackages(normalizePluginPackageNames(options?.packageNames), options?.nodeModulesDirs ?? discoverNodeModulesDirs(resolvedCwd), resolvedCwd);
+	const manifestRoots = [];
+	const skillRoots = [];
+	const tracingIncludes = [];
+	for (const pkg of discoveredPackages) {
+		const tracingBasePath = pkg.nodeModulesDir ? pathForTracingInclude(resolvedCwd, path.join(pkg.nodeModulesDir, ...pkg.packageName.split("/"))) : pathForTracingInclude(resolvedCwd, pkg.dir);
+		if (pkg.hasRootPluginManifest) {
+			manifestRoots.push(pkg.dir);
+			if (tracingBasePath) tracingIncludes.push(`${tracingBasePath}/plugin.yaml`);
+		}
+		if (pkg.hasMigrationsDir) {
+			if (tracingBasePath) tracingIncludes.push(`${tracingBasePath}/migrations/**/*`);
+		}
+		if (pkg.hasPluginsDir) {
+			manifestRoots.push(path.join(pkg.dir, "plugins"));
+			if (tracingBasePath) tracingIncludes.push(`${tracingBasePath}/plugins/**/*`);
+		}
+		if (pkg.hasSkillsDir) {
+			skillRoots.push(path.join(pkg.dir, "skills"));
+			if (tracingBasePath) tracingIncludes.push(`${tracingBasePath}/skills/**/*`);
+		}
+	}
+	return {
+		packageNames: uniqueStringsInOrder(discoveredPackages.map((pkg) => pkg.packageName)),
+		packages: discoveredPackages.map((pkg) => ({
+			dir: pkg.dir,
+			hasMigrationsDir: pkg.hasMigrationsDir,
+			hasSkillsDir: pkg.hasSkillsDir,
+			packageName: pkg.packageName
+		})),
+		manifestRoots: uniqueStringsInOrder(manifestRoots),
+		skillRoots: uniqueStringsInOrder(skillRoots),
+		tracingIncludes: uniqueStringsInOrder(tracingIncludes)
+	};
+}
+//#endregion
+export { listReferenceFiles as a, soulPathCandidates as c, resolvePackageDir as d, homeDir as i, worldPathCandidates as l, normalizePluginPackageNames as n, pluginRoots as o, discovery_exports as r, skillRoots as s, discoverInstalledPluginPackageContent as t, isValidPackageName as u };