@xopcai/xopc 0.0.302 → 0.0.306

package/dist/src/extensions/extension-registry-impl.js

@@ -12,6 +12,13 @@ var ExtensionRegistryImpl = class {
 	gatewayMethods = /* @__PURE__ */ new Map();
 	tools = /* @__PURE__ */ new Map();
 	toolExtensionIds = /* @__PURE__ */ new Map();
+	hookOwners = /* @__PURE__ */ new Map();
+	hookPriorities = /* @__PURE__ */ new Map();
+	channelOwners = /* @__PURE__ */ new Map();
+	httpRouteOwners = /* @__PURE__ */ new Map();
+	commandOwners = /* @__PURE__ */ new Map();
+	serviceOwners = /* @__PURE__ */ new Map();
+	gatewayMethodOwners = /* @__PURE__ */ new Map();
 	channelPlugins = [];
 	cliRegistrations = [];
 	reloadRegistrations = [];
@@ -26,45 +33,106 @@ var ExtensionRegistryImpl = class {
 	getEnabledExtensions() {
 		return Array.from(this.extensions.values()).filter((p) => p.enabled);
 	}
-	addHook(event, handler, _extensionId, _priority = 0) {
+	addHook(event, handler, extensionId, priority = 0) {
 		if (!this.hooks.has(event)) this.hooks.set(event, []);
-		this.hooks.get(event).push(handler);
+		const owners = this.hookOwners.get(event) ?? /* @__PURE__ */ new Map();
+		const priorities = this.hookPriorities.get(event) ?? /* @__PURE__ */ new Map();
+		owners.set(handler, extensionId);
+		priorities.set(handler, priority);
+		this.hookOwners.set(event, owners);
+		this.hookPriorities.set(event, priorities);
+		const handlers = this.hooks.get(event);
+		handlers.push(handler);
+		handlers.sort((left, right) => (priorities.get(right) ?? 0) - (priorities.get(left) ?? 0));
+	}
+	removeHook(event, handler) {
+		const handlers = this.hooks.get(event);
+		if (!handlers) return;
+		const next = handlers.filter((candidate) => candidate !== handler);
+		if (next.length > 0) this.hooks.set(event, next);
+		else this.hooks.delete(event);
+		const owners = this.hookOwners.get(event);
+		const priorities = this.hookPriorities.get(event);
+		owners?.delete(handler);
+		priorities?.delete(handler);
+		if (owners?.size === 0) this.hookOwners.delete(event);
+		if (priorities?.size === 0) this.hookPriorities.delete(event);
 	}
 	getHooks(event) {
 		return this.hooks.get(event) || [];
 	}
-	addChannelPlugin(plugin) {
+	addChannelPlugin(plugin, extensionId = "") {
 		this.channelPlugins = this.channelPlugins.filter((p) => p.id !== plugin.id);
 		this.channelPlugins.push(plugin);
+		this.channelOwners.set(plugin.id, extensionId);
 	}
-	addHttpRoute(path, handler) {
-		if (this.httpRoutes.has(path)) log.warn({ path }, `HTTP route already registered, overwriting`);
-		this.httpRoutes.set(path, handler);
+	addHttpRoute(path, handler, extensionId = "") {
+		const key = this.httpRouteKey(extensionId, path);
+		if (this.httpRoutes.has(key)) log.warn({
+			extensionId,
+			path
+		}, `HTTP route already registered, overwriting`);
+		this.httpRoutes.set(key, handler);
+		this.httpRouteOwners.set(key, extensionId);
 	}
-	getHttpRoute(path) {
-		return this.httpRoutes.get(path);
+	getHttpRoute(extensionId, path) {
+		return this.httpRoutes.get(this.httpRouteKey(extensionId, path));
 	}
-	addCommand(command) {
+	addCommand(command, extensionId = "") {
 		if (this.commands.has(command.name)) log.warn({ command: command.name }, `Command already registered, overwriting`);
 		this.commands.set(command.name, command);
+		this.commandOwners.set(command.name, extensionId);
 	}
 	getCommand(name) {
 		return this.commands.get(name);
 	}
-	addService(service) {
+	addService(service, extensionId = "") {
 		if (this.services.has(service.id)) log.warn({ service: service.id }, `Service already registered, overwriting`);
 		this.services.set(service.id, service);
+		this.serviceOwners.set(service.id, extensionId);
 	}
 	getService(id) {
 		return this.services.get(id);
 	}
-	addGatewayMethod(method, handler) {
+	addGatewayMethod(method, handler, extensionId = "") {
 		if (this.gatewayMethods.has(method)) log.warn({ method }, `Gateway method already registered, overwriting`);
 		this.gatewayMethods.set(method, handler);
+		this.gatewayMethodOwners.set(method, extensionId);
 	}
 	getGatewayMethod(method) {
 		return this.gatewayMethods.get(method);
 	}
+	getServicesForExtension(extensionId) {
+		return [...this.services.entries()].filter(([id]) => this.serviceOwners.get(id) === extensionId).map(([, service]) => service);
+	}
+	removeExtensionContributions(extensionId) {
+		for (const [event, handlers] of this.hooks) for (const handler of [...handlers]) if (this.hookOwners.get(event)?.get(handler) === extensionId) this.removeHook(event, handler);
+		for (const [name, owner] of this.toolExtensionIds) if (owner === extensionId) this.removeTool(name);
+		this.channelPlugins = this.channelPlugins.filter((plugin) => {
+			const owned = this.channelOwners.get(plugin.id) === extensionId;
+			if (owned) this.channelOwners.delete(plugin.id);
+			return !owned;
+		});
+		this.removeOwnedEntries(this.httpRoutes, this.httpRouteOwners, extensionId);
+		this.removeOwnedEntries(this.commands, this.commandOwners, extensionId);
+		this.removeOwnedEntries(this.services, this.serviceOwners, extensionId);
+		this.removeOwnedEntries(this.gatewayMethods, this.gatewayMethodOwners, extensionId);
+		this.cliRegistrations = this.cliRegistrations.filter((entry) => entry.extensionId !== extensionId);
+		this.reloadRegistrations = this.reloadRegistrations.filter((entry) => entry.extensionId !== extensionId);
+		this.migrationRegistrations = this.migrationRegistrations.filter((entry) => entry.extensionId !== extensionId);
+		this.tuiRegistrations = this.tuiRegistrations.filter((entry) => entry.extensionId !== extensionId);
+		this.extensions.delete(extensionId);
+	}
+	removeOwnedEntries(values, owners, extensionId) {
+		for (const [key, owner] of owners) {
+			if (owner !== extensionId) continue;
+			owners.delete(key);
+			values.delete(key);
+		}
+	}
+	httpRouteKey(extensionId, path) {
+		return `${extensionId}:${path.startsWith("/") ? path : `/${path}`}`;
+	}
 	addTool(tool, extensionId) {
 		if (this.tools.has(tool.name)) log.warn({ tool: tool.name }, `Tool already registered, overwriting`);
 		this.tools.set(tool.name, tool);

package/dist/src/extensions/hooks.d.ts

@@ -2,7 +2,7 @@
  * Extension Hook System
  */
 import type { ExtensionHookEvent, HookAgentContext as HookContext, AgentMessage, BeforeAgentStartContext } from './types/hooks.js';
-import { ExtensionRegistryImpl as ExtensionRegistry } from './loader.js';
+import { ExtensionRegistryImpl as ExtensionRegistry } from './extension-registry-impl.js';
 export interface HookRunnerOptions {
     catchErrors?: boolean;
     logger?: HookLogger;

package/dist/src/extensions/index.d.ts

@@ -5,7 +5,8 @@
  */
 export * from './types/index.js';
 export { ExtensionApiImpl, createExtensionLogger, createPathResolver } from './api.js';
-export { ExtensionRegistryImpl, ExtensionLoader, normalizeExtensionConfig, resolveExtensionPath, areExtensionsGloballyDisabled } from './loader.js';
+export { ExtensionRegistryImpl } from './extension-registry-impl.js';
+export { ExtensionLoader, normalizeExtensionConfig, resolveExtensionPath, areExtensionsGloballyDisabled } from './loader.js';
 export type { ActivationPlanLoadOptions } from './loader.js';
 export type { ExtensionRegistry } from './types/core.js';
 export { ManifestRegistry, type ManifestRegistryEntry } from './manifest-registry.js';

package/dist/src/extensions/install-transaction.d.ts

@@ -8,6 +8,8 @@ export interface StagedExtensionInstall {
 }
 /** Extract, validate, install dependencies, and import-check an extension away from its live path. */
 export declare function stageExtensionStoreZip(buffer: Buffer, extensionsDir: string): Promise<StagedExtensionInstall>;
+export declare function stageExtensionNpm(packageSpec: string, extensionsDir: string, timeoutMs?: number): Promise<StagedExtensionInstall>;
+export declare function stageExtensionLocal(localPath: string, extensionsDir: string): Promise<StagedExtensionInstall>;
 /** Move a staged extension into its live path, preserving the previous version for rollback. */
 export declare function commitStagedExtensionInstall(state: StagedExtensionInstall, overwrite: boolean): void;
 /** Restore the previous live extension, or remove a newly committed install. */

package/dist/src/extensions/install-transaction.js

@@ -1,36 +1,47 @@
-import { installExtensionFromStoreZip } from "./install.js";
+import { installExtensionFromStoreZip, installFromLocal, installFromNpm } from "./install.js";
 import { join } from "node:path";
 import { existsSync, mkdirSync, mkdtempSync, readFileSync, renameSync, rmSync } from "node:fs";
 import { pathToFileURL } from "node:url";
 //#region src/extensions/install-transaction.ts
-/** Extract, validate, install dependencies, and import-check an extension away from its live path. */
-async function stageExtensionStoreZip(buffer, extensionsDir) {
+async function validateStagedInstall(result, stagingRoot, extensionsDir) {
+	if (!result.ok || !result.extensionId || !result.targetDir) throw new Error(result.error ?? "Extension staging failed");
+	const manifestPath = join(result.targetDir, "xopc.extension.json");
+	const manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
+	if (!manifest.main) throw new Error("Extension manifest must declare main");
+	const mainUrl = pathToFileURL(join(result.targetDir, manifest.main));
+	mainUrl.searchParams.set("xopcInstallCheck", `${Date.now()}-${Math.random()}`);
+	await import(mainUrl.href);
+	return {
+		extensionId: result.extensionId,
+		stagingRoot,
+		stagedExtensionDir: result.targetDir,
+		targetDir: join(extensionsDir, result.extensionId),
+		committed: false
+	};
+}
+async function stageExtensionInstall(extensionsDir, install) {
 	mkdirSync(extensionsDir, { recursive: true });
 	const stagingRoot = mkdtempSync(join(extensionsDir, ".xopc-install-"));
 	try {
-		const result = await installExtensionFromStoreZip(buffer, stagingRoot);
-		if (!result.ok || !result.extensionId || !result.targetDir) throw new Error(result.error ?? "Extension staging failed");
-		const manifestPath = join(result.targetDir, "xopc.extension.json");
-		const manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
-		if (!manifest.main) throw new Error("Extension manifest must declare main");
-		const mainUrl = pathToFileURL(join(result.targetDir, manifest.main));
-		mainUrl.searchParams.set("xopcInstallCheck", `${Date.now()}-${Math.random()}`);
-		await import(mainUrl.href);
-		return {
-			extensionId: result.extensionId,
-			stagingRoot,
-			stagedExtensionDir: result.targetDir,
-			targetDir: join(extensionsDir, result.extensionId),
-			committed: false
-		};
-	} catch (err) {
+		return await validateStagedInstall(await install(stagingRoot), stagingRoot, extensionsDir);
+	} catch (error) {
 		rmSync(stagingRoot, {
 			recursive: true,
 			force: true
 		});
-		throw err;
+		throw error;
 	}
 }
+/** Extract, validate, install dependencies, and import-check an extension away from its live path. */
+async function stageExtensionStoreZip(buffer, extensionsDir) {
+	return stageExtensionInstall(extensionsDir, (stagingRoot) => installExtensionFromStoreZip(buffer, stagingRoot));
+}
+async function stageExtensionNpm(packageSpec, extensionsDir, timeoutMs) {
+	return stageExtensionInstall(extensionsDir, (stagingRoot) => installFromNpm(packageSpec, stagingRoot, timeoutMs));
+}
+async function stageExtensionLocal(localPath, extensionsDir) {
+	return stageExtensionInstall(extensionsDir, (stagingRoot) => installFromLocal(localPath, stagingRoot));
+}
 /** Move a staged extension into its live path, preserving the previous version for rollback. */
 function commitStagedExtensionInstall(state, overwrite) {
 	if (existsSync(state.targetDir)) {
@@ -71,4 +82,4 @@ function finalizeStagedExtensionInstall(state) {
 	state.backupDir = void 0;
 }
 //#endregion
-export { commitStagedExtensionInstall, finalizeStagedExtensionInstall, rollbackStagedExtensionInstall, stageExtensionStoreZip };
+export { commitStagedExtensionInstall, finalizeStagedExtensionInstall, rollbackStagedExtensionInstall, stageExtensionLocal, stageExtensionNpm, stageExtensionStoreZip };

package/dist/src/extensions/install.js

@@ -4,13 +4,14 @@ import { init_logger } from "../utils/logger.js";
 import { init_paths, resolveBundledExtensionsDir, resolveExtensionsDir as resolveExtensionsDir$1 } from "../config/paths.js";
 import { MAX_EXTENSION_STORE_ZIP_BYTES } from "./store-zip-limits.js";
 import { checkEngineCompatibility } from "./engine-check.js";
+import { EXTENSION_API_VERSION, EXTENSION_UI_API_VERSION, checkExtensionApiCompatibility } from "./api-version.js";
 import { collectExtensionPackageDependencyIssues } from "./package-contract.js";
 import { execFileSync } from "node:child_process";
 import { dirname, isAbsolute, join, resolve, sep } from "path";
 import { cpSync, existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, writeFileSync } from "fs";
 import semver from "semver";
-import AdmZip from "adm-zip";
 import { tmpdir } from "os";
+import AdmZip from "adm-zip";
 //#region src/extensions/install.ts
 /**
 * Extension Installation Module
@@ -140,6 +141,7 @@ function installExtensionProdDependencies(extensionDir) {
 			"install",
 			"--prod",
 			"--no-frozen-lockfile",
+			"--package-import-method=copy",
 			...scriptArgs
 		]);
 		if (pnpm.ok) return pnpm;
@@ -488,6 +490,21 @@ async function installFromDirectory(sourceDir, extensionsDir) {
 		ok: false,
 		error: engineCheck.reason ?? `xopc ${PACKAGE_VERSION} does not satisfy engines.xopc ${manifest.engines.xopc}`
 	};
+	for (const [engineName, requiredRange, currentVersion] of [[
+		"extensionApi",
+		manifest.engines.extensionApi,
+		EXTENSION_API_VERSION
+	], [
+		"extensionUiApi",
+		manifest.engines.extensionUiApi,
+		EXTENSION_UI_API_VERSION
+	]]) {
+		const result = checkExtensionApiCompatibility(requiredRange, currentVersion, engineName);
+		if (result.parseWarning || !result.compatible) return {
+			ok: false,
+			error: result.reason ?? `Incompatible engines.${engineName}`
+		};
+	}
 	if (!manifest.main) return {
 		ok: false,
 		error: "Extension manifest must declare main"

package/dist/src/extensions/loader.d.ts

@@ -21,8 +21,8 @@ import { type SlotRegistry } from './slots.js';
 import { type ExtensionDiagnostics } from './diagnostics.js';
 export type { ExtensionLoaderOptions, ExtensionSourceOrigin } from './discover-extensions.js';
 export { areExtensionsGloballyDisabled } from './discover-extensions.js';
-export { ExtensionRegistryImpl } from './extension-registry-impl.js';
 import { ExtensionRegistryImpl } from './extension-registry-impl.js';
+export { ExtensionRegistryImpl } from './extension-registry-impl.js';
 export interface ActivationPlanLoadOptions extends Partial<ActivationContext> {
     phase?: ActivationLoadPhase | 'all';
 }
@@ -30,6 +30,7 @@ export declare class ExtensionLoader {
     private registry;
     private options;
     private extensionInstances;
+    private startedServiceIds;
     private jiti;
     private _appConfig?;
     private _runtimeContext?;
@@ -118,6 +119,7 @@ export declare class ExtensionLoader {
      * Respects configured preferred plugin from config.extensions.slots
      */
     private claimExtensionSlots;
+    private releaseExtensionSlots;
     loadManifest(extensionPath: string): ExtensionManifest | null;
     private moduleEntryCandidates;
     private loadModule;
@@ -125,10 +127,8 @@ export declare class ExtensionLoader {
     private initializeExtension;
     startServices(): Promise<void>;
     stopServices(): Promise<void>;
-    /**
-     * Basic type validation for config values
-     */
-    private validateType;
+    unloadExtension(extensionId: string): Promise<boolean>;
+    shutdown(): Promise<void>;
 }
 export declare function resolveExtensionPath(id: string, _options: ExtensionLoaderOptions): string | null;
 export declare function normalizeExtensionConfig(rawConfig: Record<string, unknown>): ResolvedExtensionConfig[];

package/dist/src/extensions/loader.js

@@ -15,7 +15,9 @@ import { mergeActivationContext } from "./activation-context.js";
 import { checkEngineCompatibility } from "./engine-check.js";
 import { validateSpeechProviderContracts } from "./speech-provider-contracts.js";
 import { validateMediaUnderstandingProviderContracts } from "./media-provider-contracts.js";
-import { DEFAULT_SECURITY_CONFIG, checkExtensionPathSafety, isExtensionAllowed, logSecurityIssue, provenanceTracker } from "./security.js";
+import { validateExtensionConfig } from "./config-validation.js";
+import { EXTENSION_API_VERSION, EXTENSION_UI_API_VERSION, checkExtensionApiCompatibility } from "./api-version.js";
+import { DEFAULT_SECURITY_CONFIG, checkExtensionDirSafety, checkExtensionPathSafety, isExtensionAllowed, logSecurityIssue, provenanceTracker } from "./security.js";
 import { getSlotRegistry } from "./slots.js";
 import { getExtensionCache, getExtensionDiagnostics } from "./diagnostics.js";
 import { fileURLToPath, pathToFileURL } from "node:url";
@@ -59,6 +61,7 @@ var ExtensionLoader = class {
 	registry;
 	options;
 	extensionInstances = /* @__PURE__ */ new Map();
+	startedServiceIds = /* @__PURE__ */ new Set();
 	jiti;
 	_appConfig;
 	_runtimeContext;
@@ -316,6 +319,20 @@ var ExtensionLoader = class {
 				}, "Extension blocked because its path is unsafe");
 				return null;
 			}
+			if (this.securityConfig.checkPermissions) {
+				const directorySafety = checkExtensionDirSafety(extensionPath, extensionPath, source);
+				if (!directorySafety.safe) {
+					const firstIssue = directorySafety.issues[0];
+					if (firstIssue) logSecurityIssue(config.id, firstIssue);
+					const detail = firstIssue?.detail ?? "Unsafe file in extension directory";
+					this.diagnostics.error(config.id, detail);
+					log.error({
+						extensionId: config.id,
+						detail
+					}, "Extension directory safety check failed");
+					return null;
+				}
+			}
 			if (source !== "bundled" && !isExtensionAllowed(config.id, this.securityConfig)) {
 				this.diagnostics.error(config.id, "Extension is not present in extensions.security.allow");
 				log.error({
@@ -377,42 +394,40 @@ var ExtensionLoader = class {
 				this.diagnostics.error(config.id, engineResult.reason ?? "Incompatible xopc version (engines.xopc)");
 				return null;
 			}
-			if (manifest.configSchema) try {
-				const schema = manifest.configSchema;
-				const extensionConfig = config.config;
-				if (schema.type === "object" && schema.properties) {
-					const props = schema.properties;
-					const required = schema.required || [];
-					for (const field of required) if (extensionConfig[field] === void 0) {
-						log.error({
-							extensionId: config.id,
-							field
-						}, "Extension config validation failed: missing required field");
-						return null;
-					}
-					for (const [key, value] of Object.entries(extensionConfig)) {
-						const propSchema = props[key];
-						if (propSchema) {
-							if (propSchema.type && !this.validateType(value, propSchema.type)) {
-								log.error({
-									extensionId: config.id,
-									field: key,
-									expected: propSchema.type,
-									actual: typeof value
-								}, "Extension config validation failed: type mismatch");
-								return null;
-							}
-						}
-					}
+			for (const [engineName, requiredRange, currentVersion] of [[
+				"extensionApi",
+				manifest.engines.extensionApi,
+				EXTENSION_API_VERSION
+			], [
+				"extensionUiApi",
+				manifest.engines.extensionUiApi,
+				EXTENSION_UI_API_VERSION
+			]]) {
+				const result = checkExtensionApiCompatibility(requiredRange, currentVersion, engineName);
+				if (result.parseWarning || !result.compatible) {
+					const reason = result.reason ?? `Incompatible engines.${engineName}`;
+					log.warn({
+						extensionId: config.id,
+						requiredRange,
+						currentVersion
+					}, reason);
+					this.diagnostics.error(config.id, reason);
+					return null;
+				}
+			}
+			if (manifest.configSchema) {
+				const result = validateExtensionConfig(manifest.configSchema, config.config ?? {});
+				if (result.valid === false) {
+					log.error({
+						extensionId: config.id,
+						validationErrors: result.errors
+					}, `Extension config validation failed: ${result.reason}`);
+					this.diagnostics.error(config.id, `Extension config validation failed: ${result.reason}`);
+					return null;
 				}
 				log.debug({ extensionId: config.id }, "Extension config validated");
-			} catch (err) {
-				log.warn({
-					err,
-					extensionId: config.id
-				}, "Config schema validation skipped");
 			}
-			const extensionDir = dirname(extensionPath);
+			const extensionDir = extensionPath;
 			const api = this.createExtensionApi(manifest, config, extensionDir);
 			const module = await this.loadModule(extensionPath, manifest);
 			if (!module) {
@@ -421,7 +436,14 @@ var ExtensionLoader = class {
 				return null;
 			}
 			if (!this.claimExtensionSlots(config.id, manifest)) log.warn({ extensionId: config.id }, "Failed to claim required slots");
-			await this.initializeExtension(module, api, manifest);
+			try {
+				await this.initializeExtension(module, api, manifest);
+			} catch (error) {
+				api._cleanup();
+				this.registry.removeExtensionContributions(config.id);
+				this.releaseExtensionSlots(config.id);
+				throw error;
+			}
 			validateSpeechProviderContracts({
 				extensionId: config.id,
 				manifest,
@@ -490,6 +512,9 @@ var ExtensionLoader = class {
 		if (!claimed) this.diagnostics.warn(extensionId, `Slot "${slotKey}" already claimed by another extension`);
 		return claimed;
 	}
+	releaseExtensionSlots(extensionId) {
+		for (const [key, claim] of this.slotRegistry.getAllClaims()) if (claim.pluginId === extensionId) this.slotRegistry.release(key, extensionId);
+	}
 	loadManifest(extensionPath) {
 		const manifestPath = join(extensionPath, EXTENSION_MANIFEST_FILE);
 		if (existsSync(manifestPath)) try {
@@ -557,13 +582,16 @@ var ExtensionLoader = class {
 	async initializeExtension(module, api, _manifest) {
 		if (typeof module === "function") await module(api);
 		else if (typeof module === "object" && module.register) await module.register(api);
+		if (typeof module === "object" && module.activate) await module.activate(api);
 	}
 	async startServices() {
 		const services = Array.from(this.registry.services.values());
 		for (const service of services) {
+			if (this.startedServiceIds.has(service.id)) continue;
 			const serviceLog = createServiceLogger(service.id);
 			try {
 				await service.start?.();
+				this.startedServiceIds.add(service.id);
 				serviceLog.info(`Started service`);
 			} catch (error) {
 				serviceLog.error({ err: error }, `Failed to start service`);
@@ -572,27 +600,61 @@ var ExtensionLoader = class {
 	}
 	async stopServices() {
 		const services = Array.from(this.registry.services.values()).reverse();
-		for (const service of services) if (service.stop) {
+		for (const service of services) {
+			if (!this.startedServiceIds.has(service.id)) continue;
 			const serviceLog = createServiceLogger(service.id);
 			try {
-				await service.stop();
-				serviceLog.info(`Stopped service`);
+				if (service.stop) {
+					await service.stop();
+					serviceLog.info(`Stopped service`);
+				}
 			} catch (error) {
 				serviceLog.error({ err: error }, `Failed to stop service`);
+			} finally {
+				this.startedServiceIds.delete(service.id);
 			}
 		}
 	}
-	/**
-	* Basic type validation for config values
-	*/
-	validateType(value, expectedType) {
-		if (expectedType === "string") return typeof value === "string";
-		if (expectedType === "number" || expectedType === "integer") return typeof value === "number";
-		if (expectedType === "boolean") return typeof value === "boolean";
-		if (expectedType === "array") return Array.isArray(value);
-		if (expectedType === "object") return typeof value === "object" && value !== null && !Array.isArray(value);
+	async unloadExtension(extensionId) {
+		const api = this.extensionInstances.get(extensionId);
+		const record = this.registry.getExtension(extensionId);
+		if (!api || !record) return false;
+		for (const service of this.registry.getServicesForExtension(extensionId).reverse()) {
+			if (!this.startedServiceIds.has(service.id)) continue;
+			try {
+				await service.stop?.();
+			} catch (error) {
+				log.error({
+					err: error,
+					extensionId,
+					serviceId: service.id
+				}, "Extension service stop failed");
+			} finally {
+				this.startedServiceIds.delete(service.id);
+			}
+		}
+		const module = record.module;
+		try {
+			if (module && typeof module === "object" && module.deactivate) await module.deactivate(api);
+		} catch (error) {
+			log.error({
+				err: error,
+				extensionId
+			}, "Extension deactivation failed");
+		} finally {
+			api._cleanup();
+			this.registry.removeExtensionContributions(extensionId);
+			this.releaseExtensionSlots(extensionId);
+			this.extensionInstances.delete(extensionId);
+			this.cache.invalidate();
+		}
+		this.diagnostics.info(extensionId, "Unloaded extension");
 		return true;
 	}
+	async shutdown() {
+		await this.stopServices();
+		for (const extensionId of [...this.extensionInstances.keys()].reverse()) await this.unloadExtension(extensionId);
+	}
 };
 function resolveExtensionPath(id, _options) {
 	const c = loadConfig();

package/dist/src/extensions/lockfile.d.ts

@@ -1,3 +1,4 @@
+export declare function computeExtensionDirectoryIntegrity(extensionDir: string): string | undefined;
 export type ExtensionSource = 'npm' | 'local' | 'git' | 'store';
 export interface ExtensionLockEntry {
     /** Extension ID */
@@ -37,7 +38,8 @@ export interface ExtensionsLockfile {
 }
 export declare class ExtensionLockfileManager {
     private readonly lockfilePath;
-    constructor(lockfilePath?: string);
+    private readonly extensionsDir;
+    constructor(lockfilePath?: string, extensionsDir?: string);
     /**
      * Load the lockfile
      */
@@ -85,10 +87,6 @@ export declare class ExtensionLockfileManager {
      * Freeze current state (save with validation)
      */
     freeze(): Promise<ExtensionsLockfile>;
-    /**
-     * Generate integrity hash for a file
-     */
-    static generateIntegrity(filePath: string): Promise<string>;
 }
 export declare function getExtensionLockfileManager(lockfilePath?: string): ExtensionLockfileManager;
 export declare function resetExtensionLockfileManager(): void;