magus-cli 7.12.2 → 7.14.0

package/src/services/marketplace-conflicts.ts

@@ -0,0 +1,127 @@
+/**
+ * marketplace-conflicts.ts — keeping a run's work away from a marketplace
+ * whose registration on this machine is not the one the profile names.
+ *
+ * A plugin id names its marketplace only by name. When that name is
+ * registered here from another repository, anything read for that plugin
+ * comes from the other repository: its dependencies, its tool requirements,
+ * its code. `magus install` and `magus update` share this filter, so neither
+ * plans an install, a dependency or a tool from such a marketplace.
+ */
+
+import type { ResolvedClosure } from "../types/index.js";
+import {
+	type PluginDependencyReader,
+	readPluginDependencies,
+} from "./plugin-dependencies.js";
+import {
+	ownedRequirement,
+	resolvePluginBinRequirements,
+} from "./plugin-requires.js";
+import type { ResolveOptions } from "./resolver.js";
+
+/** True when `pluginId` (`name@marketplace`) comes from a conflicted marketplace. */
+export function fromConflicted(
+	pluginId: string,
+	conflicted: ReadonlySet<string>,
+): boolean {
+	const at = pluginId.lastIndexOf("@");
+	return at > 0 && conflicted.has(pluginId.slice(at + 1));
+}
+
+/**
+ * Resolver options that read nothing for a conflicted marketplace's plugins:
+ * no dependencies and no tool requirements. Resolving with them keeps what
+ * only those plugins would bring out of the closure, rather than filtering
+ * it afterwards from provenance that records only the first requirer.
+ * `readDependencies` replaces how every other plugin's dependencies are read.
+ */
+export function conflictFreeOptions(
+	conflicted: ReadonlySet<string>,
+	readDependencies?: PluginDependencyReader,
+): ResolveOptions {
+	if (conflicted.size === 0) {
+		return readDependencies ? { dependencyResolver: readDependencies } : {};
+	}
+	const read = readDependencies ?? readPluginDependencies;
+	const blocked = (id: string) => fromConflicted(id, conflicted);
+	return {
+		dependencyResolver: async (id, projectPath) =>
+			blocked(id) ? [] : read(id, projectPath),
+		binResolver: async (id) =>
+			blocked(id) ? [] : resolvePluginBinRequirements(id),
+		ownedResolver: async (id, name) =>
+			blocked(id) ? null : ownedRequirement(id, name),
+	};
+}
+
+export interface LeftOut {
+	marketplace: string;
+	plugins: string[];
+}
+
+/**
+ * The closure without the plugins of each conflicted marketplace, and
+ * without the tools only those plugins declare. Pass a closure resolved with
+ * {@link conflictFreeOptions}, so their dependencies were never added.
+ */
+export function leaveOutConflicted(
+	closure: ResolvedClosure,
+	conflicted: ReadonlySet<string>,
+): { closure: ResolvedClosure; leftOut: LeftOut[] } {
+	if (conflicted.size === 0) return { closure, leftOut: [] };
+	const plugins = { ...closure.plugins };
+	const removed = new Set<string>();
+	const leftOut: LeftOut[] = [];
+	for (const marketplace of conflicted) {
+		const ids = Object.keys(plugins).filter((id) =>
+			fromConflicted(id, new Set([marketplace])),
+		);
+		for (const id of ids) {
+			delete plugins[id];
+			removed.add(id);
+		}
+		if (ids.length > 0) leftOut.push({ marketplace, plugins: ids });
+	}
+	const bins = closure.bins.filter((b) =>
+		b.sources.some((s) => !removed.has(s.replace(/^plugin:/, ""))),
+	);
+	return { closure: { ...closure, plugins, bins }, leftOut };
+}
+
+/**
+ * The profile's marketplaces whose plugins are left out of this machine's
+ * updates: those registered or trusted here from another source, and those
+ * that could not be compared at all. A plugin from either gets no work.
+ */
+export interface MarketplaceCheck {
+	conflicted: ReadonlySet<string>;
+	/** Not compared, because reading this machine's side failed. */
+	unchecked: ReadonlySet<string>;
+}
+
+/** Nothing left out: no profile, or no marketplace that differs. */
+export const NOTHING_LEFT_OUT: MarketplaceCheck = {
+	conflicted: new Set(),
+	unchecked: new Set(),
+};
+
+/**
+ * Why `pluginId` is left out, in the user's terms, or null when it is not.
+ * The words match `magus update`'s line for the same plugin.
+ */
+export function leftOutWhy(
+	pluginId: string,
+	check: MarketplaceCheck,
+): string | null {
+	const at = pluginId.lastIndexOf("@");
+	if (at <= 0) return null;
+	const marketplace = pluginId.slice(at + 1);
+	if (check.conflicted.has(marketplace)) {
+		return `${marketplace} on this machine is not the one this project's profile names`;
+	}
+	if (check.unchecked.has(marketplace)) {
+		return `could not check that ${marketplace} on this machine is the one this project's profile names`;
+	}
+	return null;
+}

package/src/services/marketplace-refresh.ts

@@ -31,6 +31,8 @@ import {
 	getGlobalEnabledPlugins,
 	getMarketplaceAutoUpdate,
 } from "./claude-settings.js";
+import { gitEnv } from "./git-write.js";
+import { trustedRegistrations } from "./market-registry.js";
 
 /** Per-git-invocation timeout. A hung pull must never block launching Claude. */
 const GIT_TIMEOUT_MS = 30_000;
@@ -106,7 +108,14 @@ async function runGit(
 	timeoutMs: number,
 	signal?: AbortSignal,
 ): Promise<string> {
-	const r = await runBounded("git", args, { cwd, timeoutMs, signal });
+	// No prompt: a pull that needs a sign-in fails at once instead of waiting
+	// out the timeout on a prompt nobody sees.
+	const r = await runBounded("git", args, {
+		cwd,
+		timeoutMs,
+		signal,
+		env: gitEnv(),
+	});
 	if (r.spawnError) throw r.spawnError;
 	if (r.code === 0 && !r.aborted) return r.stdout;
 	const how = r.aborted
@@ -276,12 +285,33 @@ async function selectAndRefresh(
 	const configured = await getConfiguredMarketplaces();
 	const skipSet = new Set(skip);
 	const needed = await neededMarketplaces(options.pluginIds ?? []);
+	// Trusted company marketplaces, whatever their source type. A teammate's
+	// next `magus update` must see a publish made minutes ago, and only the
+	// clone carries a company plugin's catalog — so for these neither the
+	// GitHub-only rule, nor the `autoUpdate` flag, nor the once-an-hour rule
+	// applies: this machine chose to trust them, and a stale clone would hold
+	// a teammate on the old version. A `directory` registration has no clone;
+	// it is read in place.
+	const company = new Map(
+		(await trustedRegistrations()).map((r) => [r.name, r.sourceType]),
+	);
+	const names = new Set([...Object.keys(configured), ...company.keys()]);
 
 	// Select eligible marketplaces first so the pulls can run concurrently.
 	const eligible: string[] = [];
-	for (const [name, cfg] of Object.entries(configured)) {
+	for (const name of names) {
 		if (skipSet.has(name)) continue;
-		if (cfg.source?.source !== "github" || !cfg.source?.repo) {
+		const cfg = configured[name];
+		const companyType = company.get(name);
+		if (companyType !== undefined) {
+			if (companyType === "directory" || !needed.has(name)) {
+				skipped.push(name);
+				continue;
+			}
+			eligible.push(name);
+			continue;
+		}
+		if (cfg?.source?.source !== "github" || !cfg.source?.repo) {
 			skipped.push(name);
 			continue;
 		}

package/src/services/marketplace-sync.ts

@@ -1,4 +1,3 @@
-import os from "node:os";
 import path from "node:path";
 /**
  * Marketplace sync service
@@ -15,23 +14,33 @@ import path from "node:path";
  * deleted. See ai-docs/plugin-marketplace-bug-investigation.md.
  */
 import fs from "fs-extra";
-import { defaultMarketplaces } from "../data/marketplaces.js";
+import {
+	defaultMarketplaces,
+	getMarketplaceByName,
+} from "../data/marketplaces.js";
 import type { ProfileMarketplaceRef } from "../types/index.js";
+import { requireClaudeConfigDir } from "../utils/config-dir.js";
 import { parsePluginId } from "../utils/string-utils.js";
-import { addMarketplace } from "./claude-cli.js";
+import { addMarketplace, marketplaceAddHint } from "./claude-cli.js";
 import {
 	getEnabledPlugins,
 	getGlobalEnabledPlugins,
 	getLocalEnabledPlugins,
 	isMarketplaceRegistered,
 } from "./claude-settings.js";
+import {
+	isGithubSource,
+	readTrust,
+	refSource,
+	registeredMarker,
+	registeredSource,
+	sameSource,
+	trust,
+} from "./market-registry.js";
 
-const MARKETPLACES_DIR = path.join(
-	os.homedir(),
-	".claude",
-	"plugins",
-	"marketplaces",
-);
+/** Claude Code's marketplace clones, resolved per call. */
+const marketplacesDir = (): string =>
+	path.join(requireClaudeConfigDir(), "plugins", "marketplaces");
 
 /**
  * Collect unique marketplace names from enabled plugins across all settings
@@ -78,9 +87,170 @@ export async function getReferencedMarketplaces(
 /** Re-exported for convenience — canonical implementation lives in claude-settings. */
 export { isMarketplaceRegistered };
 
+/** A marketplace registration that went wrong, with what to do about it. */
+export interface RegistrationProblem {
+	name: string;
+	message: string;
+	fix?: string;
+}
+
+/** What {@link registerClosureMarketplaces} did. Nothing in it is printed. */
+export interface RegistrationResult {
+	/** Registered at USER scope by this call: `{name, source}`. */
+	added: Array<{ name: string; source: string }>;
+	/** Put on the trust list by this call, from the profile. */
+	trusted: string[];
+	/**
+	 * A company marketplace this machine registers, or trusts, from a source
+	 * other than the profile's. Nothing was changed, and its plugins must be
+	 * left out of this run's work.
+	 */
+	conflicts: RegistrationProblem[];
+	/** `claude plugin marketplace add` failed. */
+	failed: RegistrationProblem[];
+}
+
+/** The fix for a source conflict: what to check, never a removal. */
+export function conflictFix(name: string): string {
+	return `Check which one is right: \`claude plugin marketplace list\` shows this machine's source, \`.claude/profiles.json\` the profile's. If the profile is wrong, correct \`marketplaces.${name}\` there; if this machine is, ask whoever registered it before changing it.`;
+}
+
+/** A failed `marketplace add`, in the user's terms. */
+function addFailure(
+	name: string,
+	source: string,
+	error: unknown,
+): RegistrationProblem {
+	const hint = marketplaceAddHint(error);
+	const first =
+		(error instanceof Error ? error.message : String(error))
+			.split("\n")[0]
+			?.trim() || "could not be added";
+	if (hint && isGithubSource(source)) {
+		return {
+			name,
+			message: `Your GitHub account cannot read ${source} — ask its owner for access`,
+			fix: hint,
+		};
+	}
+	return { name, message: first, ...(hint ? { fix: hint } : {}) };
+}
+
 /**
- * Register every marketplace a resolved profile closure declares, skipping any
- * already known.
+ * What this machine holds for one marketplace a profile declares, read
+ * without changing anything.
+ *
+ * - `skip`: the ref names no source.
+ * - `default`: one of magus's default marketplaces; only its name is checked.
+ * - `unwatched`: registered, neither trusted nor carrying the company marker,
+ *   so its source is not compared.
+ * - `conflict`: registered, or trusted, from a source other than the profile's.
+ * - `compare`: everything else; the registration may still be added or trusted.
+ */
+type MarketplaceState =
+	| { kind: "skip" }
+	| { kind: "default"; registered: boolean; source: string }
+	| { kind: "unwatched" }
+	| { kind: "conflict"; problem: RegistrationProblem }
+	| {
+			kind: "compare";
+			registered: boolean;
+			marked: boolean;
+			machineSource: string | null;
+			profileSource: string | null;
+			source: string;
+	  };
+
+/**
+ * The source comparison {@link registerClosureMarketplaces} and
+ * {@link findMarketplaceConflicts} share. Reads Claude Code's registry, the
+ * registered clone's manifest and magus's trust list; writes nothing.
+ */
+async function inspectMarketplace(
+	name: string,
+	ref: ProfileMarketplaceRef,
+	trustList: Awaited<ReturnType<typeof readTrust>>,
+	projectRoot?: string,
+): Promise<MarketplaceState> {
+	const raw = ref.source === "github" ? ref.repo : ref.path;
+	if (!raw) return { kind: "skip" };
+	// A relative `directory` ref is relative to the project, not to wherever
+	// magus was started; Claude Code is handed the resolved path.
+	const source =
+		ref.source === "directory" && projectRoot
+			? path.resolve(projectRoot, raw)
+			: raw;
+	const profileSource = refSource(ref, projectRoot);
+	const registered = await isMarketplaceRegistered(name);
+	if (getMarketplaceByName(name))
+		return { kind: "default", registered, source };
+
+	const trusted = trustList.marketplaces[name];
+	const marked = registered && (await registeredMarker(name));
+	if (registered && !trusted && !marked) return { kind: "unwatched" };
+
+	const machineSource = registered ? await registeredSource(name) : null;
+	if (
+		registered &&
+		machineSource &&
+		profileSource &&
+		!sameSource(machineSource, profileSource)
+	) {
+		return {
+			kind: "conflict",
+			problem: {
+				name,
+				message: `${name} on this machine comes from ${machineSource}, but this project's profile says ${profileSource}. Nothing was changed.`,
+				fix: conflictFix(name),
+			},
+		};
+	}
+	if (trusted && profileSource && !sameSource(trusted.source, profileSource)) {
+		return {
+			kind: "conflict",
+			problem: {
+				name,
+				message: `${name} is a company marketplace on this machine from ${trusted.source}, but this project's profile says ${profileSource}. Nothing was changed.`,
+				fix: conflictFix(name),
+			},
+		};
+	}
+	return {
+		kind: "compare",
+		registered,
+		marked,
+		machineSource,
+		profileSource,
+		source,
+	};
+}
+
+/**
+ * The marketplaces a profile declares whose registration, or trust record,
+ * on this machine comes from another source than the profile's: the same
+ * comparison {@link registerClosureMarketplaces} makes, with nothing added,
+ * trusted or changed. Read-only callers (`magus update --dry-run` and
+ * `--check`, the Plugins screen) leave out the same plugins a real run does.
+ *
+ * Throws when a read throws; the caller decides what an unchecked answer
+ * means. `projectRoot` resolves a repo-relative `directory` ref.
+ */
+export async function findMarketplaceConflicts(
+	marketplaces: Record<string, ProfileMarketplaceRef>,
+	projectRoot?: string,
+): Promise<RegistrationProblem[]> {
+	const trustList = await readTrust();
+	const conflicts: RegistrationProblem[] = [];
+	for (const [name, ref] of Object.entries(marketplaces)) {
+		const state = await inspectMarketplace(name, ref, trustList, projectRoot);
+		if (state.kind === "conflict") conflicts.push(state.problem);
+	}
+	return conflicts;
+}
+
+/**
+ * Register every marketplace a resolved profile closure declares, and trust
+ * the company marketplaces among them.
  *
  * Shared by `install` and `update`. It lived inside cli/install.ts until
  * `update` shipped without it and could not install a plugin from a marketplace
@@ -89,23 +259,84 @@ export { isMarketplaceRegistered };
  * private or third-party marketplace failed with "not found in marketplace" and
  * no way forward.
  *
- * Failures are warned about, never thrown — one unreachable marketplace must not
- * abort the whole run.
+ * The source is compared only where trust is at stake: a name that is not one
+ * of magus's default marketplaces and that this machine already trusts, or
+ * whose registered clone carries the company marker. There, this machine's
+ * registration must come from the profile's source — a mismatch is a conflict,
+ * reported with what to check, and nothing is added, trusted or changed.
+ * Every other name keeps the name-only check: registered means done. That
+ * covers the defaults derived for any `x@magus`, which a developer may have
+ * registered from a fork or a local path on purpose. The comparison itself is
+ * {@link findMarketplaceConflicts}'s, so a read-only run finds the same
+ * conflicts.
+ *
+ * A registration that carries the marker and matches the profile's source is
+ * trusted (`via: "profile"`): the profile is the trust root for teammates.
+ *
+ * Nothing is printed and nothing is thrown: one unreachable marketplace must
+ * not abort the whole run, and the caller renders the result where its output
+ * belongs. `projectRoot` resolves a repo-relative `directory` ref.
  */
 export async function registerClosureMarketplaces(
 	marketplaces: Record<string, ProfileMarketplaceRef>,
-): Promise<void> {
+	projectRoot?: string,
+): Promise<RegistrationResult> {
+	const result: RegistrationResult = {
+		added: [],
+		trusted: [],
+		conflicts: [],
+		failed: [],
+	};
+	const trustList = await readTrust();
 	for (const [name, ref] of Object.entries(marketplaces)) {
+		const raw = ref.source === "github" ? ref.repo : ref.path;
+		if (!raw) continue;
 		try {
-			if (await isMarketplaceRegistered(name)) continue;
-			const source = ref.source === "github" ? ref.repo : ref.path;
-			if (!source) continue;
-			console.log(`+ marketplace ${name} (${source})`);
-			await addMarketplace(source);
+			const state = await inspectMarketplace(name, ref, trustList, projectRoot);
+			if (state.kind === "skip" || state.kind === "unwatched") continue;
+			if (state.kind === "conflict") {
+				result.conflicts.push(state.problem);
+				continue;
+			}
+			if (state.kind === "default") {
+				if (!state.registered) {
+					await addMarketplace(state.source, "user");
+					result.added.push({ name, source: state.source });
+				}
+				continue;
+			}
+
+			let { machineSource, marked } = state;
+			const { profileSource } = state;
+			if (!state.registered) {
+				await addMarketplace(state.source, "user");
+				result.added.push({ name, source: state.source });
+				machineSource = await registeredSource(name);
+				marked = await registeredMarker(name);
+			}
+
+			if (
+				!marked ||
+				!machineSource ||
+				!profileSource ||
+				!sameSource(machineSource, profileSource)
+			) {
+				continue;
+			}
+			const outcome = await trust(name, machineSource, "profile");
+			if (outcome === "added") result.trusted.push(name);
+			else if (outcome === "conflict") {
+				result.conflicts.push({
+					name,
+					message: `${name} is a company marketplace on this machine from another source than this project's profile (${profileSource}). Nothing was changed.`,
+					fix: conflictFix(name),
+				});
+			}
 		} catch (e) {
-			console.warn(`⚠ marketplace ${name}: ${(e as Error).message}`);
+			result.failed.push(addFailure(name, raw, e));
 		}
 	}
+	return result;
 }
 
 /**
@@ -124,14 +355,14 @@ export async function autoAddMissingMarketplaces(
 	const added: string[] = [];
 
 	for (const mpName of referenced) {
-		const mpDir = path.join(MARKETPLACES_DIR, mpName);
+		const mpDir = path.join(marketplacesDir(), mpName);
 		if (await fs.pathExists(mpDir)) continue;
 
 		const defaultMp = defaultMarketplaces.find((m) => m.name === mpName);
 		if (!defaultMp?.source.repo) continue;
 
 		try {
-			await addMarketplace(defaultMp.source.repo);
+			await addMarketplace(defaultMp.source.repo, "user");
 			added.push(mpName);
 		} catch (error) {
 			console.warn(

package/src/services/plugin-dependencies.ts

@@ -46,3 +46,20 @@ export async function readPluginDependencies(
 	const { resolvePluginDependencies } = await import("./plugin-requires.js");
 	return resolvePluginDependencies(pluginId, projectPath);
 }
+
+/**
+ * Read `pluginId`'s declared dependencies from the copy a run is about to
+ * install — its marketplace clone — before the installed one. A newly
+ * published version may depend on a plugin the installed version did not,
+ * and Claude Code refuses to load it until that one is enabled too.
+ */
+export async function readUpdatedPluginDependencies(
+	pluginId: string,
+	projectPath?: string,
+): Promise<string[] | null> {
+	if (replacement) return replacement(pluginId, projectPath);
+	const { resolvePluginDependencies } = await import("./plugin-requires.js");
+	return resolvePluginDependencies(pluginId, projectPath, {
+		cloneFirst: true,
+	});
+}

package/src/services/plugin-manager.ts

@@ -1015,7 +1015,7 @@ const autoSyncedMarketplaces = new Set<string>();
  * the local clone is stale. Log a warning but do NOT trigger a marketplace
  * update from magus.
  *
- * Previously this called `updateMarketplace()` which invokes Claude Code's
+ * Previously this ran `claude plugin marketplace update`, which invokes Claude Code's
  * `cacheMarketplaceFromGit()` — a non-atomic delete-then-clone that can
  * permanently delete the marketplace directory on clone failure.
  * Claude Code's own background autoupdate handles marketplace refreshing

package/src/services/plugin-mcp-config.ts

@@ -1,13 +1,10 @@
-import os from "node:os";
 import path from "node:path";
 import fs from "fs-extra";
+import { requireClaudeConfigDir } from "../utils/config-dir.js";
 
-const CLAUDE_PLUGINS_DIR = path.join(
-	os.homedir(),
-	".claude",
-	"plugins",
-	"marketplaces",
-);
+/** Claude Code's marketplace clones, resolved per call. */
+const claudePluginsDir = (): string =>
+	path.join(requireClaudeConfigDir(), "plugins", "marketplaces");
 
 /**
  * Represents a required environment variable for a plugin's MCP server
@@ -84,7 +81,7 @@ function getPluginMcpConfigPath(
 ): string | undefined {
 	if (!pluginSource) return undefined;
 
-	const marketplacePath = path.join(CLAUDE_PLUGINS_DIR, marketplaceName);
+	const marketplacePath = path.join(claudePluginsDir(), marketplaceName);
 	const pluginPath = path.join(
 		marketplacePath,
 		pluginSource.replace(/^\.\//, ""),
@@ -203,7 +200,7 @@ export async function getPluginSourcePath(
 	marketplaceName: string,
 	pluginName: string,
 ): Promise<string | undefined> {
-	const marketplacePath = path.join(CLAUDE_PLUGINS_DIR, marketplaceName);
+	const marketplacePath = path.join(claudePluginsDir(), marketplaceName);
 	const manifestPath = path.join(
 		marketplacePath,
 		".claude-plugin",

package/src/services/plugin-requires.ts

@@ -8,7 +8,6 @@
  * This module only locates the manifest Claude Code loads and hands it over.
  */
 
-import os from "node:os";
 import path from "node:path";
 import fs from "fs-extra";
 import {
@@ -23,13 +22,15 @@ import {
 	selectOption,
 } from "../shared/plugin/hooks/lib/requires-probe.js";
 import type { SelectedBin } from "../types/index.js";
+import { requireClaudeConfigDir } from "../utils/config-dir.js";
 import { parsePluginId } from "../utils/string-utils.js";
 import { readInstalledPluginsRegistry } from "./claude-settings.js";
+import { pluginDirFor } from "./market-layout.js";
 import { getLocalMarketplacesInfo } from "./plugin-manager.js";
 import { pickLoadedEntry } from "./plugin-resolution.js";
 
 const MARKETPLACES_DIR = (): string =>
-	path.join(os.homedir(), ".claude", "plugins", "marketplaces");
+	path.join(requireClaudeConfigDir(), "plugins", "marketplaces");
 
 /**
  * The plugin.json at a plugin directory, parsed — null when there is none or
@@ -119,6 +120,12 @@ export interface PluginManifestSources {
 	root?: string;
 	/** The plugin's source in the local marketplace clone. */
 	clone?: (pluginId: string) => Promise<string | null>;
+	/**
+	 * Trust the marketplace clone's copy before the installed one. For a
+	 * plugin a run is about to move to the clone's version: what that version
+	 * declares is what has to be in place once it loads.
+	 */
+	cloneFirst?: boolean;
 }
 
 /**
@@ -157,7 +164,10 @@ async function pluginManifestDirs(
 		// No readable registry: the clone alone decides.
 	}
 	const clone = await (sources.clone ?? resolvePluginPath)(pluginId);
-	if (clone) dirs.push(clone);
+	if (clone) {
+		if (sources.cloneFirst) dirs.unshift(clone);
+		else dirs.push(clone);
+	}
 	return [...new Set([...dirs, ...installed])];
 }
 
@@ -200,12 +210,14 @@ export async function resolvePluginPath(
 		return null;
 	}
 
-	const pluginPath = path.join(
-		MARKETPLACES_DIR(),
-		marketplace,
-		localPlugin.source.replace("./", ""),
+	// `metadata.pluginRoot` decides where a bare source lives, exactly as in
+	// the scan that listed the plugin.
+	const pluginPath = pluginDirFor(
+		path.join(MARKETPLACES_DIR(), marketplace),
+		localPlugin.source,
+		localMp.pluginRoot,
 	);
-	return (await fs.pathExists(pluginPath)) ? pluginPath : null;
+	return pluginPath && (await fs.pathExists(pluginPath)) ? pluginPath : null;
 }
 
 /**