@xopcai/xopc 0.0.321 → 0.0.323

package/dist/src/extensions/agent-plugins/health.d.ts

@@ -0,0 +1,4 @@
+export type PluginMcpHealth = 'ready' | 'authorization_required' | 'error' | 'not_tested';
+export declare function readPluginMcpHealth(id: string, name: string, revision: string, stateDir?: string): PluginMcpHealth;
+export declare function clearPluginMcpHealth(id: string, name: string, stateDir?: string): void;
+export declare function recordPluginMcpHealth(raw: unknown, status: Exclude<PluginMcpHealth, 'not_tested'>): void;

package/dist/src/extensions/agent-plugins/health.js

@@ -0,0 +1,48 @@
+import { init_paths_state, resolveStateDir } from "../../config/paths-state.js";
+import { createLogger } from "../../utils/logger/index.js";
+import { init_logger } from "../../utils/logger.js";
+import { init_write_file_atomic, writeTextAtomicSync } from "../../infra/write-file-atomic.js";
+import { pluginName } from "./validation.js";
+import { join } from "node:path";
+import { readFileSync, rmSync } from "node:fs";
+import { createHash } from "node:crypto";
+//#region src/extensions/agent-plugins/health.ts
+init_paths_state();
+init_write_file_atomic();
+init_logger();
+const log = createLogger("PluginMcpHealth");
+function pathFor(id, name, stateDir) {
+	return join(stateDir, "plugin-health", pluginName.parse(id), `${createHash("sha256").update(name).digest("hex")}.json`);
+}
+function readPluginMcpHealth(id, name, revision, stateDir = resolveStateDir()) {
+	try {
+		const value = JSON.parse(readFileSync(pathFor(id, name, stateDir), "utf8"));
+		return value.revision === revision && [
+			"ready",
+			"authorization_required",
+			"error"
+		].includes(value.status) ? value.status : "not_tested";
+	} catch {
+		return "not_tested";
+	}
+}
+function clearPluginMcpHealth(id, name, stateDir = resolveStateDir()) {
+	rmSync(pathFor(id, name, stateDir), { force: true });
+}
+function recordPluginMcpHealth(raw, status) {
+	const plugin = raw?.xopcPlugin;
+	if (!plugin) return;
+	try {
+		writeTextAtomicSync(pathFor(plugin.id, plugin.serverName, resolveStateDir()), JSON.stringify({
+			revision: plugin.revision,
+			status
+		}));
+	} catch (error) {
+		log.warn({
+			err: error,
+			pluginId: plugin.id
+		}, "Could not persist MCP connection status");
+	}
+}
+//#endregion
+export { clearPluginMcpHealth, readPluginMcpHealth, recordPluginMcpHealth };

package/dist/src/extensions/agent-plugins/inventory.d.ts

@@ -0,0 +1,53 @@
+import { type InstalledAgentPlugin } from './store.js';
+export declare function agentPluginInventoryRow(plugin: InstalledAgentPlugin): {
+    id: string;
+    pluginId: string;
+    format: "agent-plugin";
+    name: string;
+    version: string;
+    description: string;
+    source: string;
+    active: boolean;
+    activationEligible: boolean;
+    readiness: "ready" | "blocked" | "degraded" | "setup_required";
+    hasUi: boolean;
+    hasConfigSchema: boolean;
+    canRollback: boolean;
+    components: {
+        skills: {
+            name: string;
+        }[];
+        mcp: {
+            name: string;
+            id: string;
+            type: "sse" | "streamable-http" | "stdio";
+        }[];
+    };
+    diagnostics: import("./validation.js").PluginDiagnostic[];
+};
+export declare function listAgentPluginInventory(): {
+    id: string;
+    pluginId: string;
+    format: "agent-plugin";
+    name: string;
+    version: string;
+    description: string;
+    source: string;
+    active: boolean;
+    activationEligible: boolean;
+    readiness: "ready" | "blocked" | "degraded" | "setup_required";
+    hasUi: boolean;
+    hasConfigSchema: boolean;
+    canRollback: boolean;
+    components: {
+        skills: {
+            name: string;
+        }[];
+        mcp: {
+            name: string;
+            id: string;
+            type: "sse" | "streamable-http" | "stdio";
+        }[];
+    };
+    diagnostics: import("./validation.js").PluginDiagnostic[];
+}[];

package/dist/src/extensions/agent-plugins/inventory.js

@@ -0,0 +1,34 @@
+import { pluginServerId } from "./validation.js";
+import { AgentPluginStore } from "./store.js";
+//#region src/extensions/agent-plugins/inventory.ts
+function agentPluginInventoryRow(plugin) {
+	return {
+		id: `plugin:${plugin.id}`,
+		pluginId: plugin.id,
+		format: plugin.format,
+		name: plugin.manifest.name,
+		version: plugin.manifest.version,
+		description: plugin.manifest.description,
+		source: "agent-plugin",
+		active: plugin.receipt.enabled && plugin.readiness !== "blocked",
+		activationEligible: plugin.receipt.enabled,
+		readiness: plugin.readiness,
+		hasUi: false,
+		hasConfigSchema: false,
+		canRollback: !!plugin.receipt.previous,
+		components: {
+			skills: plugin.skills.map((skill) => ({ name: skill.name })),
+			mcp: Object.entries(plugin.servers).map(([name, server]) => ({
+				name,
+				id: pluginServerId(plugin.id, name),
+				type: server.type
+			}))
+		},
+		diagnostics: plugin.diagnostics
+	};
+}
+function listAgentPluginInventory() {
+	return new AgentPluginStore().list().map(agentPluginInventoryRow);
+}
+//#endregion
+export { agentPluginInventoryRow, listAgentPluginInventory };

package/dist/src/extensions/agent-plugins/mcp-adapter.d.ts

@@ -0,0 +1,3 @@
+import { AgentPluginStore, type InstalledAgentPlugin } from './store.js';
+import { type PluginDiagnostic } from './validation.js';
+export declare function materializePluginServers(plugin: InstalledAgentPlugin, store?: AgentPluginStore, diagnostics?: PluginDiagnostic[]): Record<string, Record<string, unknown>>;

package/dist/src/extensions/agent-plugins/mcp-adapter.js

@@ -0,0 +1,47 @@
+import { containedPath, expandPluginVariables, pluginServerId, resolvePluginCwd } from "./validation.js";
+import { AgentPluginStore } from "./store.js";
+import { applyPluginAuthBinding, readPluginAuthBinding } from "./auth.js";
+import { resolve } from "node:path";
+//#region src/extensions/agent-plugins/mcp-adapter.ts
+function materializePluginServers(plugin, store = new AgentPluginStore(), diagnostics = []) {
+	const root = plugin.rootDir;
+	const data = store.dataDir(plugin.id);
+	const servers = Object.create(null);
+	for (const [name, server] of Object.entries(plugin.servers)) try {
+		const origin = {
+			id: plugin.id,
+			serverName: name,
+			rootDir: root,
+			dataDir: data,
+			revision: plugin.receipt.revision
+		};
+		const raw = server.type !== "stdio" ? {
+			...server,
+			xopcPlugin: origin,
+			...server.type === "streamable-http" && !Object.keys(server.headers ?? {}).some((key) => key.toLowerCase() === "authorization") ? {
+				auth: { type: "oauth" },
+				xopcAutoAuth: true
+			} : {}
+		} : {
+			type: "stdio",
+			xopcPlugin: origin,
+			command: server.command.startsWith("./") ? containedPath(root, resolve(root, server.command)) : server.command,
+			args: server.args?.map((value) => expandPluginVariables(value, root, data)),
+			env: {
+				...Object.fromEntries(Object.entries(server.env ?? {}).map(([key, value]) => [key, expandPluginVariables(value, root, data)])),
+				PLUGIN_ROOT: root,
+				PLUGIN_DATA: data
+			},
+			cwd: resolvePluginCwd(server.cwd, root, data)
+		};
+		servers[pluginServerId(plugin.id, name)] = applyPluginAuthBinding(raw, readPluginAuthBinding(store, plugin.id, name, server));
+	} catch (error) {
+		diagnostics.push({
+			component: `mcp:${name}`,
+			message: error instanceof Error ? error.message : String(error)
+		});
+	}
+	return servers;
+}
+//#endregion
+export { materializePluginServers };

package/dist/src/extensions/agent-plugins/sources.d.ts

@@ -0,0 +1,5 @@
+import type { Config } from '../../config/schema.js';
+export declare function isAgentPluginArchive(buffer: Buffer): boolean;
+export declare function withAgentPluginArchive<T>(buffer: Buffer, fn: (local: string) => T): T;
+/** Resolve remote artifacts only for explicit inspect/install requests, never during discovery. */
+export declare function withAgentPluginSource<T>(source: string, config: Config | undefined, fn: (local: string) => T): Promise<T>;

package/dist/src/extensions/agent-plugins/sources.js

@@ -0,0 +1,72 @@
+import { createPluginHttpFetch } from "../../agent/mcp/plugin-http-fetch.js";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import AdmZip from "adm-zip";
+//#region src/extensions/agent-plugins/sources.ts
+function isAgentPluginArchive(buffer) {
+	const entries = new AdmZip(buffer).getEntries();
+	const paths = entries.map((entry) => entry.entryName.replace(/\/$/, ""));
+	const nativeMetadata = (path) => {
+		const entry = entries.find((item) => item.entryName === path);
+		if (!entry) return false;
+		if (entry.header.size > 1024 * 1024) throw new Error("Package metadata exceeds 1 MiB");
+		return Boolean(JSON.parse(entry.getData().toString("utf8"))?.xopc?.extension);
+	};
+	if (paths.includes("xopc.extension.json")) return false;
+	if (paths.includes("plugin.json")) return !nativeMetadata("package.json");
+	const first = new Set(paths.map((path) => path.split("/")[0]));
+	if (first.size !== 1) return false;
+	const root = [...first][0];
+	return paths.includes(`${root}/plugin.json`) && !paths.includes(`${root}/xopc.extension.json`) && !nativeMetadata(`${root}/package.json`);
+}
+function withAgentPluginArchive(buffer, fn) {
+	const dir = mkdtempSync(join(tmpdir(), "xopc-plugin-download-"));
+	try {
+		const file = join(dir, "plugin.zip");
+		writeFileSync(file, buffer);
+		return fn(file);
+	} finally {
+		rmSync(dir, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+/** Resolve remote artifacts only for explicit inspect/install requests, never during discovery. */
+async function withAgentPluginSource(source, config, fn) {
+	if (!source.startsWith("https://") && !source.startsWith("store:")) return fn(source);
+	let buffer;
+	if (source.startsWith("store:")) {
+		const { resolveExtensionZipDownloadUrl, resolveExtensionsStoreBaseUrl, downloadExtensionStoreZipBuffer, verifyStoreArtifactSha256 } = await import("../../agent/skills/marketplace/adapters/store/store-api-client.js");
+		const spec = source.slice(6);
+		const match = /^([a-z0-9.-]+)(?:@([^/]+))?$/.exec(spec);
+		if (!match) throw new Error("Expected store:<package>[@version]");
+		const base = resolveExtensionsStoreBaseUrl(config);
+		const artifact = await resolveExtensionZipDownloadUrl(base, match[1], match[2]);
+		buffer = await downloadExtensionStoreZipBuffer(base, artifact.downloadUrl);
+		verifyStoreArtifactSha256(buffer, artifact.sha256);
+	} else {
+		const url = new URL(source);
+		const response = await createPluginHttpFetch(url, {})(url, { signal: AbortSignal.timeout(3e4) });
+		if (!response.ok || !response.body) throw new Error(`Plugin download failed (${response.status})`);
+		const reader = response.body.getReader();
+		const chunks = [];
+		let size = 0;
+		try {
+			for (;;) {
+				const { done, value } = await reader.read();
+				if (done) break;
+				size += value.length;
+				if (size > 50 * 1024 * 1024) throw new Error("Plugin download exceeds 50 MiB");
+				chunks.push(Buffer.from(value));
+			}
+		} finally {
+			await reader.cancel();
+		}
+		buffer = Buffer.concat(chunks);
+	}
+	return withAgentPluginArchive(buffer, fn);
+}
+//#endregion
+export { isAgentPluginArchive, withAgentPluginArchive, withAgentPluginSource };

package/dist/src/extensions/agent-plugins/store.d.ts

@@ -0,0 +1,61 @@
+import { z } from 'zod';
+import { type PluginInspection } from './validation.js';
+declare const receiptSchema: z.ZodObject<{
+    id: z.ZodString;
+    revision: z.ZodString;
+    source: z.ZodString;
+    installedAt: z.ZodString;
+    enabled: z.ZodBoolean;
+    integrity: z.ZodString;
+    capabilities: z.ZodArray<z.ZodString>;
+    previous: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        source: z.ZodString;
+        installedAt: z.ZodString;
+        enabled: z.ZodBoolean;
+        integrity: z.ZodString;
+        capabilities: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type PluginReceipt = z.infer<typeof receiptSchema>;
+export interface InstalledAgentPlugin extends PluginInspection {
+    id: string;
+    format: 'agent-plugin';
+    receipt: PluginReceipt;
+    readiness: 'ready' | 'setup_required' | 'degraded' | 'blocked';
+}
+export interface PluginInstallPlan extends PluginInspection {
+    integrity: string;
+    reviewHash: string;
+    addedCapabilities: string[];
+    installed: boolean;
+}
+export declare class AgentPluginStore {
+    readonly stateDir: string;
+    constructor(stateDir?: string);
+    private receiptsDir;
+    revisionKey(): string;
+    dataDir(id: string): string;
+    private revisionDir;
+    private receiptPath;
+    receipt(id: string): PluginReceipt | undefined;
+    private write;
+    private mutate;
+    get(id: string): InstalledAgentPlugin | undefined;
+    list(): InstalledAgentPlugin[];
+    active(): InstalledAgentPlugin[];
+    inspect(source: string): PluginInstallPlan;
+    private plan;
+    install(source: string, options?: {
+        reviewHash?: string;
+        replace?: boolean;
+        expectedId?: string;
+        sourceLabel?: string;
+    }): InstalledAgentPlugin;
+    setEnabled(id: string, enabled: boolean): InstalledAgentPlugin;
+    rollback(id: string): InstalledAgentPlugin;
+    remove(id: string, removeData?: boolean): void;
+    private withSource;
+}
+export {};

package/dist/src/extensions/agent-plugins/store.js

@@ -0,0 +1,305 @@
+import { init_paths_state, resolveStateDir } from "../../config/paths-state.js";
+import { createLogger } from "../../utils/logger/index.js";
+import { init_logger } from "../../utils/logger.js";
+import { init_write_file_atomic, writeTextAtomicSync } from "../../infra/write-file-atomic.js";
+import { computeExtensionDirectoryIntegrity } from "../lockfile.js";
+import { containedPath, inspectAgentPlugin, pluginName } from "./validation.js";
+import { readPluginMcpHealth } from "./health.js";
+import { tmpdir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { cpSync, existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { createHash, randomUUID } from "node:crypto";
+import { z } from "zod";
+import AdmZip from "adm-zip";
+import lockfile from "proper-lockfile";
+//#region src/extensions/agent-plugins/store.ts
+init_paths_state();
+init_write_file_atomic();
+init_logger();
+const receiptFields = z.object({
+	id: pluginName,
+	revision: z.string().uuid(),
+	source: z.string(),
+	installedAt: z.string(),
+	enabled: z.boolean(),
+	integrity: z.string(),
+	capabilities: z.array(z.string())
+});
+const receiptSchema = receiptFields.extend({ previous: receiptFields.optional() });
+const log = createLogger("AgentPlugins");
+var AgentPluginStore = class {
+	constructor(stateDir = resolveStateDir()) {
+		this.stateDir = stateDir;
+	}
+	receiptsDir() {
+		return join(this.stateDir, "plugin-receipts");
+	}
+	revisionKey() {
+		if (!existsSync(this.receiptsDir())) return "";
+		return readdirSync(this.receiptsDir()).filter((name) => name.endsWith(".json")).sort().map((name) => {
+			try {
+				return `${name}:${statSync(join(this.receiptsDir(), name)).mtimeMs}`;
+			} catch {
+				return "";
+			}
+		}).join("|");
+	}
+	dataDir(id) {
+		return containedPath(this.stateDir, join(this.stateDir, "plugin-data", pluginName.parse(id)));
+	}
+	revisionDir(id, revision) {
+		return join(this.stateDir, "plugins", pluginName.parse(id), z.string().uuid().parse(revision));
+	}
+	receiptPath(id) {
+		return join(this.receiptsDir(), `${pluginName.parse(id)}.json`);
+	}
+	receipt(id) {
+		const path = this.receiptPath(id);
+		if (!existsSync(path)) return void 0;
+		const receipt = receiptSchema.parse(JSON.parse(readFileSync(path, "utf8")));
+		if (receipt.id !== id) throw new Error("Plugin receipt identity mismatch");
+		return receipt;
+	}
+	write(receipt) {
+		writeTextAtomicSync(this.receiptPath(receipt.id), JSON.stringify(receipt));
+	}
+	mutate(fn) {
+		mkdirSync(this.receiptsDir(), {
+			recursive: true,
+			mode: 448
+		});
+		const release = lockfile.lockSync(this.receiptsDir());
+		try {
+			return fn();
+		} finally {
+			release();
+		}
+	}
+	get(id) {
+		const receipt = this.receipt(id);
+		if (!receipt) return void 0;
+		const rootDir = this.revisionDir(id, receipt.revision);
+		try {
+			validatePackageTree(rootDir);
+			const inspection = inspectAgentPlugin(rootDir, this.dataDir(id));
+			const valid = computeExtensionDirectoryIntegrity(rootDir) === receipt.integrity;
+			if (!valid) inspection.diagnostics.push({
+				component: "package",
+				message: "Installed files differ from the reviewed package"
+			});
+			const health = Object.keys(inspection.servers).map((name) => readPluginMcpHealth(id, name, receipt.revision, this.stateDir));
+			const readiness = !valid ? "blocked" : inspection.diagnostics.length || health.includes("error") ? "degraded" : health.some((status) => status !== "ready") ? "setup_required" : "ready";
+			return {
+				...inspection,
+				id,
+				receipt,
+				format: "agent-plugin",
+				readiness
+			};
+		} catch (error) {
+			return {
+				id,
+				receipt,
+				format: "agent-plugin",
+				readiness: "blocked",
+				rootDir,
+				manifest: {
+					$schema: "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
+					name: id
+				},
+				skills: [],
+				servers: {},
+				capabilities: [],
+				diagnostics: [{
+					component: "package",
+					message: error instanceof Error ? error.message : String(error)
+				}]
+			};
+		}
+	}
+	list() {
+		if (!existsSync(this.receiptsDir())) return [];
+		return readdirSync(this.receiptsDir()).filter((name) => name.endsWith(".json")).sort().flatMap((name) => {
+			const id = name.slice(0, -5);
+			if (!pluginName.safeParse(id).success) return [];
+			try {
+				const plugin = this.get(id);
+				return plugin ? [plugin] : [];
+			} catch (error) {
+				log.warn({
+					err: error,
+					pluginId: id
+				}, "Invalid Agent Plugin receipt; package disabled");
+				return [];
+			}
+		});
+	}
+	active() {
+		if (["1", "true"].includes(process.env.XOPC_SKIP_EXTENSIONS ?? "")) return [];
+		return this.list().filter((p) => p.receipt.enabled && p.readiness !== "blocked");
+	}
+	inspect(source) {
+		return this.withSource(source, (root) => this.plan(root));
+	}
+	plan(root) {
+		validatePackageTree(root);
+		const initial = inspectAgentPlugin(root);
+		const inspection = inspectAgentPlugin(root, this.dataDir(initial.manifest.name));
+		const integrity = computeExtensionDirectoryIntegrity(root);
+		const current = this.receipt(inspection.manifest.name);
+		const addedCapabilities = inspection.capabilities.filter((c) => !current?.capabilities.includes(c));
+		const reviewHash = createHash("sha256").update(JSON.stringify([integrity, inspection.capabilities])).digest("hex");
+		return {
+			...inspection,
+			integrity,
+			reviewHash,
+			addedCapabilities,
+			installed: !!current
+		};
+	}
+	install(source, options = {}) {
+		return this.mutate(() => this.withSource(source, (root) => {
+			const plan = this.plan(root);
+			const id = plan.manifest.name;
+			if (options.expectedId && options.expectedId !== id) throw new Error("Update package identity does not match installed plugin");
+			const current = this.receipt(id);
+			if (current && !options.replace) throw new Error("Plugin already installed; use update");
+			if ((!current || plan.addedCapabilities.length > 0) && options.reviewHash !== plan.reviewHash) throw new Error("Package capability review is required");
+			if (options.reviewHash && options.reviewHash !== plan.reviewHash) throw new Error("Package changed after review; inspect again");
+			validatePackageTree(root);
+			const revision = randomUUID();
+			const target = this.revisionDir(id, revision);
+			mkdirSync(dirname(target), { recursive: true });
+			try {
+				cpSync(root, target, {
+					recursive: true,
+					dereference: false,
+					verbatimSymlinks: true
+				});
+				validatePackageTree(target);
+				const installed = inspectAgentPlugin(target, this.dataDir(id));
+				const integrity = computeExtensionDirectoryIntegrity(target);
+				if (integrity !== plan.integrity) throw new Error("Package changed during installation");
+				const label = options.sourceLabel ?? source;
+				this.write({
+					id,
+					revision,
+					source: /^(https:\/\/|store:)/.test(label) ? label : resolve(label),
+					installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+					enabled: current?.enabled ?? false,
+					integrity,
+					capabilities: installed.capabilities,
+					previous: current ? receiptFields.parse(current) : void 0
+				});
+			} catch (error) {
+				rmSync(target, {
+					recursive: true,
+					force: true
+				});
+				throw error;
+			}
+			return this.get(id);
+		}));
+	}
+	setEnabled(id, enabled) {
+		return this.mutate(() => {
+			const plugin = this.get(id);
+			if (!plugin) throw new Error("Plugin not installed");
+			if (enabled && plugin.readiness === "blocked") throw new Error("Repair the plugin before enabling it");
+			this.write({
+				...plugin.receipt,
+				enabled
+			});
+			return this.get(id);
+		});
+	}
+	rollback(id) {
+		return this.mutate(() => {
+			const receipt = this.receipt(id);
+			const previous = receipt?.previous;
+			if (!receipt || !previous || previous.id !== id) throw new Error("No rollback revision available");
+			if (computeExtensionDirectoryIntegrity(this.revisionDir(id, previous.revision)) !== previous.integrity) throw new Error("Rollback revision integrity failed");
+			this.write({
+				...previous,
+				enabled: receipt.enabled,
+				previous: receiptFields.parse(receipt)
+			});
+			return this.get(id);
+		});
+	}
+	remove(id, removeData = false) {
+		this.mutate(() => {
+			if (!this.receipt(id)) throw new Error("Plugin not installed");
+			rmSync(this.receiptPath(id));
+			rmSync(join(this.stateDir, "plugins", pluginName.parse(id)), {
+				recursive: true,
+				force: true
+			});
+			rmSync(join(this.stateDir, "plugin-health", id), {
+				recursive: true,
+				force: true
+			});
+			if (removeData) rmSync(this.dataDir(id), {
+				recursive: true,
+				force: true
+			});
+		});
+	}
+	withSource(source, fn) {
+		const path = resolve(source);
+		if (statSync(path).isDirectory()) return fn(path);
+		if (statSync(path).size > 50 * 1024 * 1024) throw new Error("Plugin archive exceeds 50 MiB");
+		const temp = mkdtempSync(join(tmpdir(), "xopc-agent-plugin-"));
+		try {
+			const entries = new AdmZip(path).getEntries();
+			if (entries.length > 1e4) throw new Error("Too many archive entries");
+			let bytes = 0;
+			const paths = /* @__PURE__ */ new Set();
+			for (const entry of entries) {
+				if (entry.entryName.includes("\\") || entry.entryName.startsWith("/") || /^[a-z]:/i.test(entry.entryName)) throw new Error("Unsafe archive path");
+				const target = containedPath(temp, join(temp, entry.entryName));
+				if (paths.has(target)) throw new Error("Duplicate archive path");
+				paths.add(target);
+				const mode = entry.attr >>> 16 & 65535;
+				if ((mode & 61440) === 40960) throw new Error("Archive symlinks are not supported");
+				bytes += entry.header.size;
+				if (bytes > 100 * 1024 * 1024) throw new Error("Expanded archive exceeds 100 MiB");
+				if (entry.isDirectory) mkdirSync(target, { recursive: true });
+				else {
+					mkdirSync(dirname(target), { recursive: true });
+					const data = entry.getData();
+					if (data.length !== entry.header.size) throw new Error("Archive size mismatch");
+					writeFileSync(target, data, {
+						mode: mode & 73 ? 493 : 420,
+						flag: "wx"
+					});
+				}
+			}
+			const children = readdirSync(temp);
+			return fn(existsSync(join(temp, "plugin.json")) ? temp : children.length === 1 ? join(temp, children[0]) : temp);
+		} finally {
+			rmSync(temp, {
+				recursive: true,
+				force: true
+			});
+		}
+	}
+};
+function validatePackageTree(root) {
+	let files = 0;
+	let bytes = 0;
+	const visit = (path, ancestors) => {
+		const safe = containedPath(root, path);
+		if (ancestors.has(safe)) throw new Error("Cyclic package symlink");
+		const stat = statSync(safe);
+		if (++files > 1e4 || (bytes += stat.isFile() ? stat.size : 0) > 100 * 1024 * 1024) throw new Error("Package exceeds limits");
+		if (stat.isDirectory()) {
+			const next = new Set([...ancestors, safe]);
+			for (const name of readdirSync(safe)) visit(join(path, name), next);
+		} else if (!stat.isFile()) throw new Error("Unsupported package file type");
+		if (lstatSync(path).isFile() && stat.nlink > 1) throw new Error("Package hardlinks are not supported");
+	};
+	visit(root, /* @__PURE__ */ new Set());
+}
+//#endregion
+export { AgentPluginStore };