@dex-ai/coding-agent 0.1.92

package/src/commands/extension-loader.ts

@@ -0,0 +1,399 @@
+/**
+ * Extension loader — loads installed extensions from registry.
+ *
+ * Reads registry.json from user and project scopes, resolves each extension's
+ * entry point from its isolated node_modules/, and imports it.
+ *
+ * Each extension is expected to export:
+ *   - default: Extension | Extension[] (native dex extension)
+ *   - For pi-compat: detected via "pi" field in package.json, loaded via @dex-ai/pi-compat
+ */
+
+import { existsSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { homedir } from "node:os";
+import type { Extension } from "@dex-ai/sdk";
+
+/* ------------------------------------------------------------------ */
+/* Constants                                                            */
+/* ------------------------------------------------------------------ */
+
+const USER_EXTENSIONS_DIR = join(homedir(), ".dex", "extensions");
+const USER_PACKAGES_DIR = join(USER_EXTENSIONS_DIR, "packages");
+const USER_REGISTRY_PATH = join(USER_EXTENSIONS_DIR, "registry.json");
+
+/**
+ * Extensions that are always injected by CodingAgent.create() (the SDK layer).
+ * User-installed copies of these would result in duplicates — skip loading them.
+ */
+const SDK_BUILTIN_PACKAGES = new Set([
+	"@dex-ai/tools-extension",
+	"@dex-ai/skills-extension",
+	"@dex-ai/ask-extension",
+]);
+
+/* ------------------------------------------------------------------ */
+/* Types                                                               */
+/* ------------------------------------------------------------------ */
+
+interface RegistryEntry {
+	source: "npm" | "file";
+	package: string;
+	version?: string;
+	path?: string;
+	type?: "native" | "pi-compat";
+	installedAt: string;
+}
+
+interface Registry {
+	version: 1;
+	extensions: Record<string, RegistryEntry>;
+}
+
+/* ------------------------------------------------------------------ */
+/* Registry reading                                                    */
+/* ------------------------------------------------------------------ */
+
+function loadRegistry(registryPath: string): Registry {
+	if (!existsSync(registryPath)) {
+		return { version: 1, extensions: {} };
+	}
+	try {
+		const data = JSON.parse(readFileSync(registryPath, "utf-8"));
+		if (data.version === 1 && data.extensions) return data;
+		return { version: 1, extensions: {} };
+	} catch {
+		return { version: 1, extensions: {} };
+	}
+}
+
+/* ------------------------------------------------------------------ */
+/* Entry point resolution                                              */
+/* ------------------------------------------------------------------ */
+
+/**
+ * Resolve the entry point for an extension package.
+ *
+ * Checks in order:
+ * 1. package.json "dex.extensions" field
+ * 2. package.json "exports"."." field
+ * 3. package.json "main" field
+ * 4. index.ts / index.js
+ */
+function resolveEntryPoint(packageDir: string): string | null {
+	const pkgJsonPath = join(packageDir, "package.json");
+	if (!existsSync(pkgJsonPath)) return null;
+
+	try {
+		const pkg = JSON.parse(readFileSync(pkgJsonPath, "utf-8"));
+
+		// 1. dex.extensions field
+		if (pkg.dex?.extensions?.length) {
+			const first = pkg.dex.extensions[0];
+			const resolved = join(packageDir, first);
+			if (existsSync(resolved)) return resolved;
+		}
+
+		// 2. exports."." field
+		if (pkg.exports?.["."]?.default) {
+			const resolved = join(packageDir, pkg.exports["."].default);
+			if (existsSync(resolved)) return resolved;
+		}
+		if (pkg.exports?.["."]) {
+			const exp = pkg.exports["."];
+			if (typeof exp === "string") {
+				const resolved = join(packageDir, exp);
+				if (existsSync(resolved)) return resolved;
+			}
+		}
+
+		// 3. main field
+		if (pkg.main) {
+			const resolved = join(packageDir, pkg.main);
+			if (existsSync(resolved)) return resolved;
+		}
+
+		// 4. index.ts / index.js
+		const indexTs = join(packageDir, "index.ts");
+		if (existsSync(indexTs)) return indexTs;
+		const indexJs = join(packageDir, "index.js");
+		if (existsSync(indexJs)) return indexJs;
+
+		// 5. src/index.ts (common convention)
+		const srcIndexTs = join(packageDir, "src", "index.ts");
+		if (existsSync(srcIndexTs)) return srcIndexTs;
+
+		return null;
+	} catch {
+		return null;
+	}
+}
+
+/* ------------------------------------------------------------------ */
+/* Pi-compat loading                                                   */
+/* ------------------------------------------------------------------ */
+
+async function loadPiCompatExtension(
+	extensionDir: string,
+	packageName: string,
+): Promise<Extension | null> {
+	// Find @dex-ai/pi-compat — check user packages first
+	const piCompatDir = join(USER_PACKAGES_DIR, "pi-compat");
+	const piCompatPkgDir = join(
+		piCompatDir,
+		"node_modules",
+		"@dex-ai",
+		"pi-compat",
+	);
+
+	if (!existsSync(piCompatPkgDir)) {
+		console.error(
+			`Cannot load pi-compat extension "${packageName}": @dex-ai/pi-compat is not installed.`,
+		);
+		console.error(
+			"Install it with: dex extension install npm:@dex-ai/pi-compat",
+		);
+		return null;
+	}
+
+	try {
+		const piCompatEntry = resolveEntryPoint(piCompatPkgDir);
+		if (!piCompatEntry) {
+			console.error(
+				"Cannot resolve @dex-ai/pi-compat entry point. Try reinstalling it.",
+			);
+			return null;
+		}
+
+		const piCompat = await import(piCompatEntry);
+		const piCompatExtension =
+			piCompat.piCompatExtension ?? piCompat.default?.piCompatExtension;
+
+		if (typeof piCompatExtension !== "function") {
+			console.error(
+				"@dex-ai/pi-compat does not export piCompatExtension function.",
+			);
+			return null;
+		}
+
+		// The pi-compat adapter loads the extension from the package's node_modules
+		const packageDir = join(extensionDir, "node_modules", packageName);
+		const ext = await piCompatExtension({
+			paths: [packageDir],
+		});
+		return ext;
+	} catch (err) {
+		console.error(
+			`Failed to load pi-compat extension "${packageName}":`,
+			err instanceof Error ? err.message : err,
+		);
+		return null;
+	}
+}
+
+/* ------------------------------------------------------------------ */
+/* Native extension loading                                            */
+/* ------------------------------------------------------------------ */
+
+async function loadNativeExtension(
+	extensionDir: string,
+	packageName: string,
+): Promise<Extension[]> {
+	const packageDir = join(extensionDir, "node_modules", packageName);
+
+	if (!existsSync(packageDir)) {
+		console.error(`Extension package not found at: ${packageDir}`);
+		return [];
+	}
+
+	const entryPoint = resolveEntryPoint(packageDir);
+	if (!entryPoint) {
+		console.error(
+			`Cannot resolve entry point for "${packageName}" in ${packageDir}`,
+		);
+		return [];
+	}
+
+	try {
+		const mod = await import(entryPoint);
+		const ext = mod.default;
+
+		if (Array.isArray(ext)) {
+			return ext.filter(
+				(e: unknown) => e && typeof e === "object" && (e as any).name,
+			);
+		}
+		if (ext && typeof ext === "object" && ext.name) {
+			return [ext];
+		}
+		if (typeof ext === "function") {
+			let result = ext();
+			// Await if the factory returns a promise (async factories)
+			if (
+				result &&
+				typeof result === "object" &&
+				typeof result.then === "function"
+			) {
+				result = await result;
+			}
+			if (result && typeof result === "object" && result.name) {
+				return [result];
+			}
+		}
+
+		// Try named exports
+		const extensions: Extension[] = [];
+		for (const [key, value] of Object.entries(mod)) {
+			if (key === "default") continue;
+
+			// Named export is already an Extension object
+			if (value && typeof value === "object" && (value as any).name) {
+				extensions.push(value as Extension);
+				continue;
+			}
+
+			// Named export is a factory function (e.g. devtoolsExtension())
+			if (typeof value === "function" && key.includes("xtension")) {
+				try {
+					let result = (value as Function)();
+					// Await if the factory returns a promise (async factories)
+					if (
+						result &&
+						typeof result === "object" &&
+						typeof result.then === "function"
+					) {
+						result = await result;
+					}
+					if (result && typeof result === "object" && (result as any).name) {
+						extensions.push(result as Extension);
+					}
+				} catch {
+					// Factory requires args — skip
+				}
+			}
+		}
+		if (extensions.length > 0) return extensions;
+
+		// Extension loaded but no Extension objects found.
+		// This is normal for extensions that require configuration.
+		return [];
+	} catch (err) {
+		console.error(
+			`Failed to load extension "${packageName}":`,
+			err instanceof Error ? err.message : err,
+		);
+		return [];
+	}
+}
+
+/* ------------------------------------------------------------------ */
+/* Public API                                                          */
+/* ------------------------------------------------------------------ */
+
+export interface LoadedExtensions {
+	extensions: Extension[];
+	providers: Map<string, Extension>;
+}
+
+/**
+ * Load all installed extensions from user and project registries.
+ * Project scope wins on name collision.
+ */
+export async function loadInstalledExtensions(
+	cwd: string,
+): Promise<LoadedExtensions> {
+	const extensions: Extension[] = [];
+	const providers = new Map<string, Extension>();
+
+	// Load registries
+	const userRegistry = loadRegistry(USER_REGISTRY_PATH);
+	const projectRegistryPath = join(cwd, ".dex", "extensions", "registry.json");
+
+	// Skip project scope if it resolves to the same path as user scope
+	const isSamePath =
+		resolve(projectRegistryPath) === resolve(USER_REGISTRY_PATH);
+	const projectRegistry = isSamePath
+		? { version: 1 as const, extensions: {} as Record<string, RegistryEntry> }
+		: loadRegistry(projectRegistryPath);
+
+	// Merge: project wins on collision
+	const merged: Record<
+		string,
+		{ entry: RegistryEntry; scope: "user" | "project" }
+	> = {};
+	for (const [name, entry] of Object.entries(userRegistry.extensions)) {
+		merged[name] = { entry, scope: "user" };
+	}
+	for (const [name, entry] of Object.entries(projectRegistry.extensions)) {
+		merged[name] = { entry, scope: "project" };
+	}
+
+	// Prepend installed extension binaries to PATH
+	for (const [name, { scope }] of Object.entries(merged)) {
+		const extDir =
+			scope === "project"
+				? join(cwd, ".dex", "extensions", name)
+				: join(USER_PACKAGES_DIR, name);
+		const binPath = join(extDir, "node_modules", ".bin");
+		if (existsSync(binPath)) {
+			process.env.PATH = `${binPath}:${process.env.PATH}`;
+		}
+	}
+
+	// Load each extension
+	for (const [name, { entry, scope }] of Object.entries(merged)) {
+		// Skip extensions that the SDK injects internally (avoids duplicates)
+		if (SDK_BUILTIN_PACKAGES.has(entry.package)) {
+			continue;
+		}
+
+		const extensionDir =
+			scope === "project"
+				? join(cwd, ".dex", "extensions", name)
+				: join(USER_PACKAGES_DIR, name);
+
+		if (!existsSync(extensionDir)) {
+			console.error(
+				`Extension "${name}" directory not found. Run: dex extension install ${entry.source}:${entry.package}`,
+			);
+			continue;
+		}
+
+		if (entry.type === "pi-compat") {
+			const ext = await loadPiCompatExtension(extensionDir, entry.package);
+			if (ext) {
+				// Pi-compat extensions may provide models (providers)
+				if ((ext as any).models && (ext as any).models.length > 0) {
+					providers.set(name, ext);
+				} else {
+					extensions.push(ext);
+				}
+			}
+		} else {
+			const exts = await loadNativeExtension(extensionDir, entry.package);
+			for (const ext of exts) {
+				if ((ext as any).models && (ext as any).models.length > 0) {
+					providers.set(name, ext);
+				} else {
+					extensions.push(ext);
+				}
+			}
+		}
+	}
+
+	return { extensions, providers };
+}
+
+/**
+ * Get the disabled extensions list from settings.
+ */
+export function getDisabledExtensions(): string[] {
+	const settingsPath = join(homedir(), ".dex", "settings.json");
+	if (!existsSync(settingsPath)) return [];
+	try {
+		const settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
+		return settings.extensions?.disabled ?? [];
+	} catch {
+		return [];
+	}
+}