@xopcai/xopc 0.0.396 → 0.0.397

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

@@ -9,6 +9,11 @@ declare const bindingSchema: z.ZodObject<{
     }>;
     identityScope: z.ZodLiteral<"owner">;
     endpointFingerprint: z.ZodString;
+    oauthReference: z.ZodOptional<z.ZodObject<{
+        sourceServerId: z.ZodString;
+        credentialId: z.ZodString;
+        fingerprint: z.ZodString;
+    }, z.core.$strict>>;
     fields: z.ZodArray<z.ZodObject<{
         target: z.ZodEnum<{
             headers: "headers";
@@ -23,7 +28,7 @@ export type PluginAuthBinding = z.infer<typeof bindingSchema>;
 export declare const pluginCredentialProviderPrefix: (id: string) => string;
 export declare const parsePluginAuthBinding: (value: unknown) => PluginAuthBinding;
 export declare function pluginEndpointFingerprint(server: PluginServer): string;
-export declare function readPluginAuthBinding(store: AgentPluginStore, id: string, name: string, server: PluginServer): PluginAuthBinding | undefined;
+export declare function readPluginAuthBinding(store: AgentPluginStore, id: string, name: string, server: PluginServer, revision?: string): PluginAuthBinding | undefined;
 export declare function savePluginAuthBinding(store: AgentPluginStore, id: string, name: string, input: {
     mode: PluginAuthBinding['mode'];
     secrets?: Array<{
@@ -33,5 +38,6 @@ export declare function savePluginAuthBinding(store: AgentPluginStore, id: strin
         prefix?: string;
     }>;
 }): Promise<void>;
+export declare function savePluginOAuthReference(store: AgentPluginStore, id: string, name: string, reference: NonNullable<PluginAuthBinding['oauthReference']>): void;
 export declare function applyPluginAuthBinding(raw: Record<string, unknown>, binding: PluginAuthBinding | undefined): Record<string, unknown>;
 export {};

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

@@ -1,5 +1,5 @@
 import { init_paths_state, resolveStateDir } from "../../config/paths-state.js";
-import { init_write_file_atomic, writeTextAtomic } from "../../infra/write-file-atomic.js";
+import { init_write_file_atomic, writeTextAtomic, writeTextAtomicSync } from "../../infra/write-file-atomic.js";
 import { CredentialResolver, init_credentials } from "../../auth/credentials.js";
 import { isDangerousHostEnvVarName } from "../../infra/host-env-security.js";
 import { pluginName } from "./validation.js";
@@ -17,6 +17,11 @@ const bindingSchema = z.strictObject({
 	mode: z.enum(["auto", "api-key"]),
 	identityScope: z.literal("owner"),
 	endpointFingerprint: z.string(),
+	oauthReference: z.strictObject({
+		sourceServerId: z.string(),
+		credentialId: z.string().regex(/^mcp_draft_[a-f0-9]{32}$/),
+		fingerprint: z.string()
+	}).optional(),
 	fields: z.array(z.strictObject({
 		target: z.enum(["headers", "env"]),
 		key: z.string(),
@@ -28,19 +33,36 @@ const hash = (value) => createHash("sha256").update(value).digest("hex");
 const pluginCredentialProviderPrefix = (id) => `plugin-${hash(id).slice(0, 16)}-`;
 const parsePluginAuthBinding = (value) => bindingSchema.parse(value);
 function pluginEndpointFingerprint(server) {
-	return hash(server.type === "stdio" ? JSON.stringify(server) : new URL(server.url).toString());
+	return hash(server.type === "stdio" ? JSON.stringify(server) : JSON.stringify([
+		new URL(server.url).toString(),
+		server.oauth ?? null,
+		server.connectionAuth ?? null
+	]));
 }
-function bindingPath(store, id, name) {
-	return join(store.stateDir, "plugin-auth", pluginName.parse(id), `${hash(name)}.json`);
+function bindingPath(store, id, name, revision) {
+	return join(store.stateDir, "plugin-auth", pluginName.parse(id), `${hash(name)}${revision ? `-${z.string().uuid().parse(revision)}` : ""}.json`);
 }
-function readPluginAuthBinding(store, id, name, server) {
-	const path = bindingPath(store, id, name);
-	if (!existsSync(path)) return void 0;
-	const binding = bindingSchema.parse(JSON.parse(readFileSync(path, "utf8")));
-	return binding.endpointFingerprint === pluginEndpointFingerprint(server) ? binding : void 0;
+function readPluginAuthBinding(store, id, name, server, revision) {
+	const current = store.receipt(id);
+	const targetRevision = revision ?? current?.revision;
+	const revisions = [...new Set([
+		targetRevision,
+		current?.revision,
+		current?.previous?.revision
+	].filter((value) => !!value))];
+	for (const candidate of [...revisions.map((value) => bindingPath(store, id, name, value)), bindingPath(store, id, name)]) {
+		if (!existsSync(candidate)) continue;
+		const binding = bindingSchema.parse(JSON.parse(readFileSync(candidate, "utf8")));
+		const fingerprint = pluginEndpointFingerprint(server);
+		const legacy = server.type !== "stdio" && !server.oauth && !server.connectionAuth && binding.endpointFingerprint === hash(new URL(server.url).toString());
+		if (binding.endpointFingerprint !== fingerprint && !legacy) continue;
+		if (legacy) binding.endpointFingerprint = fingerprint;
+		if (targetRevision && candidate !== bindingPath(store, id, name, targetRevision)) writeTextAtomicSync(bindingPath(store, id, name, targetRevision), JSON.stringify(binding));
+		return binding;
+	}
 }
 async function savePluginAuthBinding(store, id, name, input) {
-	const plugin = store.get(id);
+	const plugin = store.pending(id) ?? store.get(id);
 	const server = plugin?.servers[name];
 	if (!server || plugin?.readiness === "blocked") throw new Error("Plugin MCP server unavailable");
 	const endpointFingerprint = pluginEndpointFingerprint(server);
@@ -67,6 +89,7 @@ async function savePluginAuthBinding(store, id, name, input) {
 		const provider = `${pluginCredentialProviderPrefix(id)}${hash(JSON.stringify([
 			"owner",
 			id,
+			plugin.receipt.revision,
 			name,
 			endpointFingerprint,
 			field.target,
@@ -87,7 +110,21 @@ async function savePluginAuthBinding(store, id, name, input) {
 		endpointFingerprint,
 		fields
 	});
-	await writeTextAtomic(bindingPath(store, id, name), JSON.stringify(binding));
+	await writeTextAtomic(bindingPath(store, id, name, plugin.receipt.revision), JSON.stringify(binding));
+}
+function savePluginOAuthReference(store, id, name, reference) {
+	const plugin = store.pending(id) ?? store.get(id);
+	const server = plugin?.servers[name];
+	if (!server || !plugin || plugin.readiness === "blocked") throw new Error("Plugin MCP server unavailable");
+	const binding = bindingSchema.parse({
+		serverName: name,
+		mode: "auto",
+		identityScope: "owner",
+		endpointFingerprint: pluginEndpointFingerprint(server),
+		fields: [],
+		oauthReference: reference
+	});
+	writeTextAtomicSync(bindingPath(store, id, name, plugin.receipt.revision), JSON.stringify(binding));
 }
 function applyPluginAuthBinding(raw, binding) {
 	if (!binding) return raw;
@@ -103,8 +140,12 @@ function applyPluginAuthBinding(raw, binding) {
 		} };
 		result[field.target] = values;
 	}
+	if (binding.oauthReference) {
+		result.xopcOAuthCredentialId = binding.oauthReference.credentialId;
+		result.xopcPluginOAuthReference = binding.oauthReference;
+	}
 	result.xopcAuthRevision = hash(JSON.stringify(binding));
 	return result;
 }
 //#endregion
-export { applyPluginAuthBinding, parsePluginAuthBinding, pluginCredentialProviderPrefix, pluginEndpointFingerprint, readPluginAuthBinding, savePluginAuthBinding };
+export { applyPluginAuthBinding, parsePluginAuthBinding, pluginCredentialProviderPrefix, pluginEndpointFingerprint, readPluginAuthBinding, savePluginAuthBinding, savePluginOAuthReference };

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

@@ -0,0 +1,6 @@
+import { type PluginManifest } from './validation.js';
+/** Inline bounded package assets so authenticated and offline inventories need no extra fetch. */
+export declare function pluginBranding(root: string, manifest: PluginManifest): {
+    iconUrl: string;
+    iconSha256: string;
+};

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

@@ -0,0 +1,44 @@
+import { containedPath } from "./validation.js";
+import { extname, resolve } from "node:path";
+import { readFileSync, statSync } from "node:fs";
+import { createHash } from "node:crypto";
+//#region src/extensions/agent-plugins/branding.ts
+/** Inline bounded package assets so authenticated and offline inventories need no extra fetch. */
+function pluginBranding(root, manifest) {
+	const icon = (manifest.extensions?.["ai.xopc"])?.branding?.icon;
+	if (typeof icon !== "string" || !icon || icon.includes("\0")) return void 0;
+	try {
+		const file = containedPath(root, resolve(root, icon));
+		const info = statSync(file);
+		if (!info.isFile() || info.size < 1 || info.size > 128 * 1024) return void 0;
+		const type = extname(file).toLowerCase();
+		const mime = {
+			".svg": "image/svg+xml",
+			".png": "image/png",
+			".webp": "image/webp"
+		}[type];
+		if (!mime) return void 0;
+		const bytes = readFileSync(file);
+		if (type === ".svg") {
+			const source = bytes.toString("utf8");
+			if (!/<svg\b/i.test(source) || /<(?:script|foreignObject|iframe|object|embed)\b|\son[a-z]+\s*=|(?:href|src)\s*=\s*["']\s*(?:https?:|\/\/|data:)/i.test(source)) return void 0;
+		} else if (type === ".png" ? !bytes.subarray(0, 8).equals(Buffer.from([
+			137,
+			80,
+			78,
+			71,
+			13,
+			10,
+			26,
+			10
+		])) : bytes.subarray(0, 4).toString() !== "RIFF" || bytes.subarray(8, 12).toString() !== "WEBP") return void 0;
+		return {
+			iconUrl: `data:${mime};base64,${bytes.toString("base64")}`,
+			iconSha256: createHash("sha256").update(bytes).digest("hex")
+		};
+	} catch {
+		return;
+	}
+}
+//#endregion
+export { pluginBranding };

package/dist/src/extensions/agent-plugins/cli-authorization.d.ts

@@ -0,0 +1,22 @@
+import { type PluginAuthorization } from './setup-contract.js';
+import type { AgentPluginStore, InstalledAgentPlugin } from './store.js';
+type CliMethod = Extract<PluginAuthorization['methods'][number], {
+    type: 'cli';
+}>;
+export type PluginCliAuthorization = {
+    id: string;
+    state: 'preparing' | 'awaiting_user' | 'connected' | 'error' | 'cancelled';
+    expiresAt: number;
+    challenge?: {
+        type: 'url' | 'qr';
+        url: string;
+        message?: string;
+    };
+    error?: string;
+};
+export declare function checkPluginCliAuthorization(store: AgentPluginStore, plugin: InstalledAgentPlugin, authorization: string, method: CliMethod, signal: AbortSignal): Promise<boolean>;
+export declare function startPluginCliAuthorization(store: AgentPluginStore, plugin: InstalledAgentPlugin, authorization: string, method: CliMethod, owner: string): PluginCliAuthorization;
+export declare function getPluginCliAuthorization(id: string, owner: string, revision: string): PluginCliAuthorization | undefined;
+export declare function cancelPluginCliAuthorizations(pluginId: string, owner?: string): void;
+export declare function cancelAllPluginCliAuthorizations(): void;
+export {};

package/dist/src/extensions/agent-plugins/cli-authorization.js

@@ -0,0 +1,198 @@
+import { CredentialResolver, init_credentials } from "../../auth/credentials.js";
+import { spawnProcess } from "../../process/run-process.js";
+import { safeAuthorizationUrl } from "./setup-contract.js";
+import { containedPath, expandPluginVariables, resolvePluginCwd, validatePluginServer } from "./validation.js";
+import { expandUserConfig, readPluginUserConfig } from "./user-config.js";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+import { mkdirSync, readFileSync } from "node:fs";
+import { randomUUID } from "node:crypto";
+//#region src/extensions/agent-plugins/cli-authorization.ts
+init_credentials();
+const attempts = /* @__PURE__ */ new Map();
+async function execute(store, plugin, authorization, command, signal, timeoutMs, onLine) {
+	validatePluginServer({
+		type: "stdio",
+		...command
+	}, plugin.rootDir, store.dataDir(plugin.id));
+	const data = store.dataDir(plugin.id), home = join(data, "accounts", plugin.receipt.revision, authorization);
+	mkdirSync(home, {
+		recursive: true,
+		mode: 448
+	});
+	const values = {
+		...Object.fromEntries(Object.entries(plugin.layout?.userConfig ?? {}).filter(([, field]) => field.default !== void 0).map(([key, field]) => [key, field.default])),
+		...readPluginUserConfig(store, plugin.id, plugin.receipt.revision)
+	};
+	const expand = (value) => expandUserConfig(expandPluginVariables(value.replace(/\$\{PLUGIN_RESOURCES\}/g, join(data, "resources", plugin.receipt.revision)), plugin.rootDir, data), values);
+	const environment = Object.fromEntries([
+		"PATH",
+		"SystemRoot",
+		"WINDIR",
+		"TMPDIR",
+		"TEMP",
+		"TMP",
+		"LANG"
+	].flatMap((key) => process.env[key] === void 0 ? [] : [[key, process.env[key]]]));
+	Object.assign(environment, {
+		HOME: home,
+		USERPROFILE: home,
+		XDG_CONFIG_HOME: join(home, "config"),
+		PLUGIN_HOST_HOME: homedir(),
+		PLUGIN_ACCOUNT_HOME: home,
+		PLUGIN_ROOT: plugin.rootDir,
+		PLUGIN_DATA: data,
+		PLUGIN_RESOURCES: join(data, "resources", plugin.receipt.revision)
+	});
+	const resolver = new CredentialResolver({ stateDir: store.stateDir });
+	for (const [key, value] of Object.entries(command.env)) {
+		const expanded = expand(value);
+		if (typeof expanded === "string") environment[key] = expanded;
+		else {
+			const reference = expanded;
+			if (!reference.xopcSecretRef) throw new Error("Invalid login credential reference");
+			const secret = await resolver.resolveApiKey(reference.xopcSecretRef.provider);
+			if (!secret) throw new Error("Login credential is unavailable");
+			environment[key] = reference.xopcSecretRef.prefix + secret;
+		}
+	}
+	const program = command.command.startsWith("./") ? containedPath(plugin.rootDir, resolve(plugin.rootDir, command.command)) : command.command.startsWith("${PLUGIN_RESOURCES}/") ? containedPath(data, join(data, "resources", plugin.receipt.revision, command.command.slice(20))) : command.command;
+	let pending = "";
+	const result = await spawnProcess({
+		program,
+		args: command.args.map((arg) => {
+			const value = expand(arg);
+			if (typeof value !== "string") throw new Error("Use environment variables for login secrets");
+			return value;
+		}),
+		cwd: resolvePluginCwd(command.cwd, plugin.rootDir, data),
+		env: environment,
+		signal,
+		timeoutMs,
+		maxOutputBytes: 65536,
+		terminationPolicy: "tree",
+		shell: false,
+		onOutput(stream, chunk) {
+			if (stream !== "stdout" || !onLine) return;
+			pending = (pending + chunk.toString("utf8")).slice(-65536);
+			let boundary;
+			while ((boundary = pending.indexOf("\n")) >= 0) {
+				const line = pending.slice(0, boundary);
+				pending = pending.slice(boundary + 1);
+				onLine(line);
+			}
+		}
+	}).completion;
+	if (result.exitCode !== 0 || result.timedOut || result.aborted || result.outputTruncated) throw new Error("CLI login or account check failed. Retry authorization.");
+	return result.stdout;
+}
+async function checkPluginCliAuthorization(store, plugin, authorization, method, signal) {
+	try {
+		const last = (await execute(store, plugin, authorization, method.check, signal, 15e3)).trim().split("\n").at(-1);
+		return !!last && JSON.parse(last).authenticated === true;
+	} catch {
+		signal.throwIfAborted();
+		return false;
+	}
+}
+function startPluginCliAuthorization(store, plugin, authorization, method, owner) {
+	for (const [key, attempt] of attempts) if (attempt.view.expiresAt < Date.now()) {
+		attempt.controller.abort();
+		attempts.delete(key);
+	} else if (attempt.pluginId === plugin.id && attempt.authorization === authorization) {
+		if (attempt.owner !== owner) throw new Error("Authorization belongs to another principal");
+		attempt.controller.abort();
+		attempt.view.state = "cancelled";
+	}
+	const controller = new AbortController();
+	const view = {
+		id: randomUUID(),
+		state: "preparing",
+		expiresAt: Date.now() + method.timeoutSeconds * 1e3
+	};
+	const attempt = {
+		owner,
+		pluginId: plugin.id,
+		revision: plugin.receipt.revision,
+		authorization,
+		view,
+		controller
+	};
+	attempts.set(view.id, attempt);
+	const watcher = setInterval(() => {
+		try {
+			const current = store.pendingReceipt(plugin.id) ?? store.receipt(plugin.id);
+			const job = JSON.parse(readFileSync(join(store.stateDir, "plugin-setup", `${plugin.id}.json`), "utf8"));
+			const target = job.authorizations?.find((value) => value.id === authorization);
+			if (current?.revision !== plugin.receipt.revision || job.packageRevision !== plugin.receipt.revision || target?.attemptId !== view.id || ["cancelled", "completed"].includes(job.state)) controller.abort();
+		} catch {
+			controller.abort();
+		}
+	}, 500);
+	watcher.unref();
+	(async () => {
+		try {
+			await execute(store, plugin, authorization, method.login, controller.signal, method.timeoutSeconds * 1e3, (line) => {
+				try {
+					const value = JSON.parse(line);
+					if (value.type === "challenge" && ["qr", "url"].includes(value.kind) && typeof value.url === "string" && value.url.length <= 8192) {
+						view.challenge = {
+							type: value.kind,
+							url: safeAuthorizationUrl(value.url),
+							...typeof value.message === "string" && value.message.length <= 300 ? { message: value.message } : {}
+						};
+						view.state = "awaiting_user";
+					}
+				} catch {}
+			});
+			controller.signal.throwIfAborted();
+			if ((store.pending(plugin.id) ?? store.get(plugin.id))?.receipt.revision !== plugin.receipt.revision) throw new Error("Plugin revision changed");
+			if (!await checkPluginCliAuthorization(store, plugin, authorization, method, controller.signal)) throw new Error("Account verification failed");
+			view.state = "connected";
+			delete view.challenge;
+		} catch {
+			view.state = controller.signal.aborted ? "cancelled" : "error";
+			view.error = controller.signal.aborted ? "Sign-in cancelled." : "Sign-in or account verification failed. Retry authorization.";
+			delete view.challenge;
+		} finally {
+			clearInterval(watcher);
+		}
+	})();
+	return view;
+}
+function getPluginCliAuthorization(id, owner, revision) {
+	const attempt = attempts.get(id);
+	if (!attempt) return;
+	if (attempt.owner !== owner || attempt.revision !== revision) throw new Error("Authorization does not match this installation");
+	if (attempt.view.expiresAt <= Date.now() && ![
+		"connected",
+		"error",
+		"cancelled"
+	].includes(attempt.view.state)) {
+		attempt.controller.abort();
+		attempt.view.state = "error";
+		attempt.view.error = "Sign-in expired. Try again.";
+		delete attempt.view.challenge;
+	}
+	return attempt.view;
+}
+function cancelPluginCliAuthorizations(pluginId, owner) {
+	for (const attempt of attempts.values()) if (attempt.pluginId === pluginId && (owner === void 0 || attempt.owner === owner)) {
+		attempt.controller.abort();
+		attempt.view.state = "cancelled";
+		delete attempt.view.challenge;
+	}
+}
+function cancelAllPluginCliAuthorizations() {
+	for (const attempt of attempts.values()) {
+		attempt.controller.abort();
+		if (![
+			"connected",
+			"error",
+			"cancelled"
+		].includes(attempt.view.state)) attempt.view.state = "cancelled";
+		delete attempt.view.challenge;
+	}
+}
+//#endregion
+export { cancelAllPluginCliAuthorizations, cancelPluginCliAuthorizations, checkPluginCliAuthorization, getPluginCliAuthorization, startPluginCliAuthorization };

package/dist/src/extensions/agent-plugins/connection-reuse.d.ts

@@ -0,0 +1,10 @@
+import type { Config } from '../../config/schema.js';
+import type { PluginServer } from './validation.js';
+export interface PluginOAuthReference {
+    sourceServerId: string;
+    credentialId: string;
+    fingerprint: string;
+}
+export declare function connectionFingerprint(server: Record<string, unknown>): string;
+export declare function matchingReusableConnection(target: PluginServer, source: Record<string, unknown>): boolean;
+export declare function validPluginOAuthReference(reference: PluginOAuthReference, config: Config, target?: PluginServer): boolean;

package/dist/src/extensions/agent-plugins/connection-reuse.js

@@ -0,0 +1,23 @@
+import { createHash } from "node:crypto";
+//#region src/extensions/agent-plugins/connection-reuse.ts
+function connectionFingerprint(server) {
+	return createHash("sha256").update(JSON.stringify([
+		server.url,
+		server.oauth ?? null,
+		server.auth ?? null,
+		server.headers ?? null,
+		server.xopcOAuthCredentialId
+	])).digest("hex");
+}
+function settings(value) {
+	return JSON.stringify(Object.fromEntries(Object.entries(value && typeof value === "object" ? value : {}).sort(([a], [b]) => a.localeCompare(b))));
+}
+function matchingReusableConnection(target, source) {
+	return target.type !== "stdio" && target.connectionAuth?.mode !== "api-key" && source.enabled !== false && source.url === target.url && typeof source.xopcOAuthCredentialId === "string" && /^mcp_draft_[a-f0-9]{32}$/.test(source.xopcOAuthCredentialId) && !source.auth && !Object.keys(source.headers ?? {}).some((key) => key.toLowerCase() === "authorization") && !Object.keys(target.headers ?? {}).some((key) => key.toLowerCase() === "authorization") && settings(source.oauth) === settings(target.oauth);
+}
+function validPluginOAuthReference(reference, config, target) {
+	const source = config.mcp?.servers?.[reference.sourceServerId];
+	return !!source && (!target || matchingReusableConnection(target, source)) && source.enabled !== false && source.xopcOAuthCredentialId === reference.credentialId && connectionFingerprint(source) === reference.fingerprint;
+}
+//#endregion
+export { connectionFingerprint, matchingReusableConnection, validPluginOAuthReference };

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

@@ -1,7 +1,10 @@
 import { init_paths_state, resolveStateDir } from "../../config/paths-state.js";
 import { CredentialResolver, init_credentials } from "../../auth/credentials.js";
-import { pluginName } from "./validation.js";
+import { pluginName, pluginServerId } from "./validation.js";
+import { createNativeMcpCredentials } from "../../agent/mcp/credential-store.js";
 import { pluginCredentialProviderPrefix } from "./auth.js";
+import { pluginOAuthCredentialId } from "./mcp-adapter.js";
+import { getNativePiAgentDir } from "../../agent/mcp/native-mcp.js";
 import { join } from "node:path";
 import { existsSync, rmSync } from "node:fs";
 //#region src/extensions/agent-plugins/credentials.ts
@@ -9,6 +12,19 @@ init_credentials();
 init_paths_state();
 async function removePluginCredentials(store, id) {
 	pluginName.parse(id);
+	const history = store.history(id);
+	if (store.stateDir === resolveStateDir()) {
+		getNativePiAgentDir();
+		const native = await createNativeMcpCredentials();
+		for (const plugin of history) {
+			const servers = plugin.receipt.oauthServers ?? Object.fromEntries(Object.entries(plugin.servers).filter(([, server]) => server.type !== "stdio").map(([name, server]) => [name, server.type !== "stdio" ? server.url : ""]));
+			for (const [name, url] of Object.entries(servers)) {
+				const alias = plugin.receipt.credentialScope === "revision" ? pluginOAuthCredentialId(id, plugin.receipt.revision, name) : pluginServerId(id, name);
+				await native.forServer(alias, url).save({ serverUrl: url });
+				native.remove(alias, url);
+			}
+		}
+	}
 	const dir = join(store.stateDir, "plugin-auth", id);
 	const resolver = new CredentialResolver(store.stateDir === resolveStateDir() ? {} : { stateDir: store.stateDir });
 	for (const profile of await resolver.listProfiles()) if (profile.provider.startsWith(pluginCredentialProviderPrefix(id))) await resolver.deleteProviderCredential(profile.provider);
@@ -16,6 +32,13 @@ async function removePluginCredentials(store, id) {
 		recursive: true,
 		force: true
 	});
+	for (const plugin of history) {
+		rmSync(join(store.stateDir, "plugin-config", `${id}-${plugin.receipt.revision}.json`), { force: true });
+		rmSync(join(store.dataDir(id), "accounts", plugin.receipt.revision), {
+			recursive: true,
+			force: true
+		});
+	}
 }
 //#endregion
 export { removePluginCredentials };

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

@@ -0,0 +1,27 @@
+export declare const PLUGIN_MANIFEST_PATHS: readonly ["plugin.json", ".codex-plugin/plugin.json", ".claude-plugin/plugin.json"];
+export type PluginDialect = 'portable' | 'codex' | 'claude';
+export interface CompatibilityItem {
+    component: string;
+    support: 'supported' | 'needs_adapter' | 'unsupported' | 'invalid';
+    message: string;
+}
+export interface PluginLayout {
+    descriptorVersion: 1;
+    adapterVersion: 'xopc-plugin-v1';
+    dialect: PluginDialect;
+    manifest: Record<string, unknown>;
+    skillRoots: string[];
+    mcpConfigs: unknown[];
+    compatibility: CompatibilityItem[];
+    userConfig: Record<string, {
+        type: 'string' | 'number' | 'boolean';
+        title: string;
+        required: boolean;
+        sensitive: boolean;
+        default?: string | number | boolean;
+    }>;
+    tasks: string[];
+}
+/** Interpret each dialect before applying the common package and execution checks. */
+export declare function readPluginLayout(root: string, read: (path: string) => string, safe: (path: string) => string, importManifest?: Record<string, unknown>): PluginLayout;
+export declare function collectPluginSkillFiles(root: string, safe: (path: string) => string): string[];