@xopcai/xopc 0.0.312 → 0.0.314

package/dist/src/local-apps/scaffold.js

@@ -1,7 +1,10 @@
+import { ExtensionCapabilityBindingsSchema, extensionCapabilityPermissions } from "../../packages/gateway-contract/src/extension-capabilities.js";
+import { init_src } from "../../packages/gateway-contract/src/index.js";
 import { LOCAL_APP_RUNTIME_ENTRY, LOCAL_APP_RUNTIME_SOURCE } from "./runtime-entry.js";
 import { dirname, join } from "node:path";
 import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
 //#region src/local-apps/scaffold.ts
+init_src();
 const LOCAL_APP_PERMISSIONS = ["theme", "storage"];
 function writeText(root, relativePath, content) {
 	const target = join(root, relativePath);
@@ -111,7 +114,7 @@ button?.addEventListener('click', () => {
 function readLocalAppPermissions(workspaceRoot) {
 	try {
 		const raw = JSON.parse(readFileSync(join(workspaceRoot, "xopc.extension.json"), "utf8"));
-		return Array.isArray(raw.ui?.permissions) ? raw.ui.permissions.filter((permission) => typeof permission === "string") : [];
+		return [...Array.isArray(raw.ui?.permissions) ? raw.ui.permissions.filter((permission) => typeof permission === "string") : [], ...extensionCapabilityPermissions(ExtensionCapabilityBindingsSchema.parse(raw.ui?.capabilities ?? []))];
 	} catch {
 		return [];
 	}

package/dist/src/local-apps/service.d.ts

@@ -3,6 +3,10 @@ import type { ExtensionLoader } from '../extensions/index.js';
 import type { ProjectService } from '../projects/index.js';
 import { LocalAppStore } from './store.js';
 import type { CreateLocalAppInput, LocalApp, LocalAppAcceptanceRun, LocalAppDetail, LocalAppPreviewTarget, LocalAppValidationResult, LocalAppUiGrant, RecordLocalAppAcceptanceInput } from './types.js';
+export declare class LocalAppRevisionConflictError extends Error {
+}
+export declare class LocalAppAcceptanceValidationError extends Error {
+}
 export interface LocalAppServiceOptions {
     projects: ProjectService;
     workspaceRoot: string;
@@ -18,20 +22,39 @@ export declare class LocalAppService {
     private readonly options;
     private readonly store;
     constructor(options: LocalAppServiceOptions, store?: LocalAppStore);
+    private recoveryRoot;
+    private recoveryMarker;
+    /** Reconcile interrupted mutations before any extension code or request can run. */
+    recoverPendingReleases(): Promise<void>;
+    private recoverReleases;
+    private mutateRelease;
     list(): LocalApp[];
     get(id: string): LocalAppDetail | null;
     getUiGrant(extensionId: string): LocalAppUiGrant;
-    grantUiPermissions(extensionId: string): LocalAppUiGrant;
+    getCapabilityAccess(extensionId: string, expectedManifestDigest: string): {
+        releaseId: string;
+        bindings: {
+            id: "xopc.notes.get" | "xopc.notes.list" | "xopc.tasks.get" | "xopc.tasks.list" | "xopc.notes.create" | "xopc.notes.update" | "xopc.notes.append";
+            majorVersion: number;
+            descriptorDigest: string;
+        }[];
+    };
+    grantUiPermissions(extensionId: string, expectedManifestDigest: string): LocalAppUiGrant;
     create(input: CreateLocalAppInput): LocalAppDetail;
     resolvePreview(previewToken: string): LocalAppPreviewTarget | null;
     validate(id: string): LocalAppValidationResult;
     recordAcceptance(id: string, input: RecordLocalAppAcceptanceInput): LocalAppAcceptanceRun;
+    flushAcceptanceEvents(): void;
     private releaseRoot;
     private refreshExtensions;
     private assertInstalledRuntime;
     private activateArtifact;
     install(id: string): Promise<LocalAppDetail>;
+    private installRelease;
     rollback(id: string, releaseId: string): Promise<LocalAppDetail>;
+    private rollbackRelease;
     setEnabled(id: string, enabled: boolean): Promise<LocalAppDetail>;
+    private setReleaseEnabled;
     uninstall(id: string): Promise<LocalAppDetail>;
+    private uninstallRelease;
 }

package/dist/src/local-apps/service.js

@@ -1,18 +1,29 @@
 import { resolveStateDir } from "../config/paths-state.js";
 import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
+import { currentOperationId, init_operation_context } from "../infra/operation-context.js";
+import { afterSqliteCommit, init_transaction, runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
+import { ExtensionCapabilityBindingsSchema, extensionCapabilityPermissions } from "../../packages/gateway-contract/src/extension-capabilities.js";
+import { init_src } from "../../packages/gateway-contract/src/index.js";
 import { init_paths, resolveExtensionsDir } from "../config/paths.js";
 import { LocalAppStore } from "./store.js";
 import { slugifyProjectName } from "../projects/project-store.js";
+import { CapabilityError } from "../capabilities/runtime/errors.js";
+import { DomainOutboxDispatcher } from "../infra/domain-outbox-dispatcher.js";
+import { validateLocalAppCapabilityContracts } from "./capabilities/contracts.js";
 import { readLocalAppAcceptanceConfig } from "./acceptance.js";
-import { LOCAL_APP_RUNTIME_ENTRY, LOCAL_APP_RUNTIME_SOURCE, legacyLocalAppRuntimeSource } from "./runtime-entry.js";
+import { LOCAL_APP_RUNTIME_ENTRY, LOCAL_APP_RUNTIME_SOURCE } from "./runtime-entry.js";
 import { readLocalAppPermissions, scaffoldLocalApp } from "./scaffold.js";
+import { withLocalAppReleaseLock } from "./release-lock.js";
 import { basename, join, relative, resolve, sep } from "node:path";
-import { cpSync, existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, renameSync, rmSync } from "node:fs";
-import { createHash, randomBytes } from "node:crypto";
+import { cpSync, existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { createHash, randomBytes, randomUUID } from "node:crypto";
 //#region src/local-apps/service.ts
+init_src();
 init_paths();
 init_logger();
+init_transaction();
+init_operation_context();
 const log = createLogger("LocalApps");
 const RELEASE_COPY_EXCLUDED_NAMES = new Set([".git", "node_modules"]);
 const UI_ONLY_PERMISSIONS = new Set([
@@ -20,6 +31,21 @@ const UI_ONLY_PERMISSIONS = new Set([
 	"storage",
 	"notification"
 ]);
+function cleanupReleaseStaging(path) {
+	try {
+		rmSync(path, {
+			recursive: true,
+			force: true
+		});
+	} catch (err) {
+		log.warn({
+			err,
+			path
+		}, "Local app staging cleanup failed; retained for inspection");
+	}
+}
+var LocalAppRevisionConflictError = class extends Error {};
+var LocalAppAcceptanceValidationError = class extends Error {};
 function requireText(value, label) {
 	const trimmed = value.trim();
 	if (!trimmed) throw new Error(`${label} is required`);
@@ -118,7 +144,7 @@ function permissionsFromManifestJson(manifestJson) {
 	if (!manifestJson) return [];
 	try {
 		const manifest = JSON.parse(manifestJson);
-		return Array.isArray(manifest.ui?.permissions) ? manifest.ui.permissions.filter((value) => typeof value === "string") : [];
+		return [...Array.isArray(manifest.ui?.permissions) ? manifest.ui.permissions.filter((value) => typeof value === "string") : [], ...extensionCapabilityPermissions(ExtensionCapabilityBindingsSchema.parse(manifest.ui?.capabilities ?? []))];
 	} catch {
 		return [];
 	}
@@ -135,10 +161,11 @@ function validateLocalAppPackage(root, extensionId) {
 		const resolvedPath = resolve(root, declaredPath);
 		if (!resolvedPath.startsWith(`${resolvedRoot}${sep}`) || !existsSync(resolvedPath) || !lstatSync(resolvedPath).isFile()) throw new Error(`Declared app file is missing or unsafe: ${declaredPath}`);
 	}
-	const trustedRuntime = manifest.main === ".xopc/runtime/local-ui.js" ? LOCAL_APP_RUNTIME_SOURCE : manifest.main === "index.js" && typeof manifest.name === "string" ? legacyLocalAppRuntimeSource(extensionId, manifest.name) : null;
+	const trustedRuntime = manifest.main === ".xopc/runtime/local-ui.js" ? LOCAL_APP_RUNTIME_SOURCE : null;
 	if (trustedRuntime === null || readFileSync(join(root, manifest.main), "utf8") !== trustedRuntime) throw new Error(`Phase 1 local apps must use the xopc-owned runtime entry: ${LOCAL_APP_RUNTIME_ENTRY}`);
 	const unsupported = (Array.isArray(manifest.ui.permissions) ? manifest.ui.permissions.filter((value) => typeof value === "string") : []).filter((permission) => !UI_ONLY_PERMISSIONS.has(permission));
 	if (unsupported.length) throw new Error(`Phase 1 local apps cannot request: ${unsupported.join(", ")}`);
+	validateLocalAppCapabilityContracts(manifest.ui.capabilities);
 	const html = readFileSync(join(root, manifest.ui.main), "utf8");
 	if (/<script\b(?![^>]*\bsrc=)[^>]*>/i.test(html)) throw new Error("Inline scripts are blocked in local app previews");
 	if (/(?:src|href)\s*=\s*["']https?:\/\//i.test(html)) throw new Error("Remote scripts, styles, and frames are blocked in Phase 1 local apps");
@@ -156,6 +183,80 @@ var LocalAppService = class {
 		this.options = options;
 		this.store = store;
 	}
+	recoveryRoot() {
+		return join(resolveStateDir(), "local-apps", "pending-releases");
+	}
+	recoveryMarker(id) {
+		if (!/^[a-zA-Z0-9-]+$/.test(id)) throw new Error("Invalid local app id");
+		return join(this.recoveryRoot(), id);
+	}
+	/** Reconcile interrupted mutations before any extension code or request can run. */
+	async recoverPendingReleases() {
+		return withLocalAppReleaseLock(resolveExtensionsDir(), () => this.recoverReleases());
+	}
+	async recoverReleases() {
+		if (!existsSync(this.recoveryRoot())) return;
+		for (const id of readdirSync(this.recoveryRoot())) {
+			const marker = this.recoveryMarker(id);
+			const app = this.store.get(id);
+			if (!app) throw new Error(`Pending local app recovery has no database record: ${id}`);
+			if (!/^[a-zA-Z0-9-]+$/.test(app.extensionId)) throw new Error("Invalid local app extension id");
+			const extensionsDir = resolveExtensionsDir();
+			mkdirSync(extensionsDir, { recursive: true });
+			const target = join(extensionsDir, app.extensionId);
+			if (app.installationState === "installed") {
+				const release = app.activeReleaseId ? this.store.getRelease(id, app.activeReleaseId) : null;
+				if (!release || resolve(release.artifactPath) !== resolve(this.releaseRoot(id), `v${release.version}`)) throw new Error(`Local app recovery release is unavailable: ${id}`);
+				validateLocalAppPackage(release.artifactPath, app.extensionId);
+				if (hashDirectory(release.artifactPath) !== release.sourceHash) throw new Error(`Local app recovery integrity check failed: ${id}`);
+				const staging = mkdtempSync(join(extensionsDir, ".local-app-recover-"));
+				try {
+					const replacement = join(staging, app.extensionId);
+					cpSync(release.artifactPath, replacement, {
+						recursive: true,
+						filter: shouldCopyReleasePath
+					});
+					rmSync(target, {
+						recursive: true,
+						force: true
+					});
+					renameSync(replacement, target);
+				} finally {
+					cleanupReleaseStaging(staging);
+				}
+			} else rmSync(target, {
+				recursive: true,
+				force: true
+			});
+			const config = this.options.getConfig();
+			const saved = await this.options.saveConfig(app.installationState === "installed" ? setExtensionActivation(config, app.extensionId, app.enabled) : removeExtensionActivation(config, app.extensionId));
+			if (!saved.saved) throw new Error(saved.error ?? `Local app recovery config save failed: ${id}`);
+			const orphan = join(this.releaseRoot(id), `v${app.draftVersion}`);
+			if (!this.store.listReleases(id).some((release) => resolve(release.artifactPath) === resolve(orphan)) && existsSync(orphan)) renameSync(orphan, join(mkdtempSync(join(this.releaseRoot(id), ".interrupted-")), "package"));
+			this.refreshExtensions("local-app-recovery");
+			rmSync(marker);
+			log.info({
+				appId: id,
+				releaseId: app.activeReleaseId
+			}, "Interrupted local app release recovered");
+		}
+	}
+	async mutateRelease(id, action) {
+		return withLocalAppReleaseLock(resolveExtensionsDir(), async () => {
+			await this.recoverReleases();
+			if (!this.store.get(id)) throw new Error("Local app not found");
+			const marker = this.recoveryMarker(id);
+			mkdirSync(this.recoveryRoot(), { recursive: true });
+			writeFileSync(marker, "", {
+				flag: "wx",
+				mode: 384,
+				flush: true
+			});
+			const result = await action();
+			rmSync(marker);
+			return result;
+		});
+	}
 	list() {
 		return this.store.list();
 	}
@@ -177,8 +278,11 @@ var LocalAppService = class {
 		const discovered = !release ? this.options.getExtensionLoader()?.discoverExtensions().find((extension) => extension.id === extensionId) : null;
 		if (!release && !discovered) throw new Error("Extension UI manifest not found");
 		const manifestJson = release?.manifestJson ?? JSON.stringify(discovered.manifest);
-		const manifestDigest = createHash("sha256").update(manifestJson).digest("hex");
-		const permissions = release ? permissionsFromManifestJson(manifestJson).toSorted() : [...discovered.manifest.ui?.permissions ?? []].toSorted();
+		const manifestDigest = createHash("sha256").update(release ? JSON.stringify({
+			manifestJson,
+			sourceHash: release.sourceHash
+		}) : manifestJson).digest("hex");
+		const permissions = release ? permissionsFromManifestJson(manifestJson).toSorted() : [...discovered.manifest.ui?.permissions ?? [], ...extensionCapabilityPermissions(discovered.manifest.ui?.capabilities ?? [])].toSorted();
 		const grant = this.store.getUiGrant(extensionId, manifestDigest);
 		const granted = Boolean(grant && JSON.stringify(grant.permissions.toSorted()) === JSON.stringify(permissions));
 		return {
@@ -190,9 +294,26 @@ var LocalAppService = class {
 			grantedAt: granted ? grant?.grantedAt : void 0
 		};
 	}
-	grantUiPermissions(extensionId) {
+	getCapabilityAccess(extensionId, expectedManifestDigest) {
+		const app = this.store.findByExtensionId(extensionId);
+		const config = extensionConfigRecord(this.options.getConfig());
+		if (app && existsSync(this.recoveryMarker(app.id))) throw new CapabilityError("FORBIDDEN", "Local app release mutation or recovery is pending");
+		if (!app || !app.enabled || app.installationState !== "installed" || !app.activeReleaseId || stringIds(config.disabled).includes(extensionId) || !stringIds(config.enabled).includes(extensionId)) throw new CapabilityError("FORBIDDEN", "Local app is not enabled and installed");
+		const grant = this.getUiGrant(extensionId);
+		if (!grant.granted) throw new CapabilityError("FORBIDDEN", "Local app permissions have not been granted");
+		if (grant.manifestDigest !== expectedManifestDigest) throw new CapabilityError("CONTRACT_CHANGED", "Local app release changed");
+		const release = this.store.getRelease(app.id, app.activeReleaseId);
+		if (!release) throw new CapabilityError("FORBIDDEN", "Local app release is unavailable");
+		const manifest = JSON.parse(release.manifestJson);
+		return {
+			releaseId: release.id,
+			bindings: ExtensionCapabilityBindingsSchema.parse(manifest.ui?.capabilities ?? [])
+		};
+	}
+	grantUiPermissions(extensionId, expectedManifestDigest) {
 		const current = this.getUiGrant(extensionId);
 		if (!current.manifestDigest) throw new Error("Extension UI manifest not found");
+		if (current.manifestDigest !== expectedManifestDigest) throw new Error("Extension release changed; review permissions again");
 		return this.store.saveUiGrant({
 			extensionId,
 			appId: current.appId,
@@ -306,10 +427,10 @@ var LocalAppService = class {
 		const app = this.store.get(id);
 		if (!app) throw new Error("Local app not found");
 		const validation = this.validate(id);
-		if (validation.status !== "healthy" || !validation.sourceHash) throw new Error("The current draft must pass static validation before acceptance can be recorded");
-		if (input.sourceHash !== validation.sourceHash) throw new Error("Acceptance result is stale because the draft changed");
-		if (input.status !== "passed" && input.status !== "failed") throw new Error("Invalid acceptance status");
-		if (!Number.isInteger(input.interactiveCount) || input.interactiveCount < 0 || input.interactiveCount > 1e4) throw new Error("Invalid acceptance interactive count");
+		if (validation.status !== "healthy" || !validation.sourceHash) throw new LocalAppAcceptanceValidationError("The current draft must pass static validation before acceptance can be recorded");
+		if (input.sourceHash !== validation.sourceHash) throw new LocalAppRevisionConflictError("Acceptance result is stale because the draft changed");
+		if (input.status !== "passed" && input.status !== "failed") throw new LocalAppAcceptanceValidationError("Invalid acceptance status");
+		if (!Number.isInteger(input.interactiveCount) || input.interactiveCount < 0 || input.interactiveCount > 1e4) throw new LocalAppAcceptanceValidationError("Invalid acceptance interactive count");
 		const requiredIds = new Set([
 			"document",
 			"content",
@@ -322,23 +443,33 @@ var LocalAppService = class {
 			"failed",
 			"skipped"
 		]);
-		if (!Array.isArray(input.checks) || input.checks.length < requiredIds.size || input.checks.length > allowedIds.size) throw new Error("Automatic acceptance must include every required check");
+		if (!Array.isArray(input.checks) || input.checks.length < requiredIds.size || input.checks.length > allowedIds.size) throw new LocalAppAcceptanceValidationError("Automatic acceptance must include every required check");
 		const seenIds = /* @__PURE__ */ new Set();
 		for (const check of input.checks) {
-			if (!allowedIds.has(check.id) || seenIds.has(check.id)) throw new Error("Invalid automatic acceptance check");
-			if (!allowedStatuses.has(check.status)) throw new Error("Invalid automatic acceptance check status");
-			if (typeof check.message !== "string" || !check.message.trim() || check.message.length > 500) throw new Error("Invalid automatic acceptance check message");
+			if (!allowedIds.has(check.id) || seenIds.has(check.id)) throw new LocalAppAcceptanceValidationError("Invalid automatic acceptance check");
+			if (!allowedStatuses.has(check.status)) throw new LocalAppAcceptanceValidationError("Invalid automatic acceptance check status");
+			if (typeof check.message !== "string" || !check.message.trim() || check.message.length > 500) throw new LocalAppAcceptanceValidationError("Invalid automatic acceptance check message");
 			seenIds.add(check.id);
 		}
-		if ([...requiredIds].some((checkId) => !seenIds.has(checkId))) throw new Error("Automatic acceptance must include every required check");
-		if ((input.checks.some((check) => check.status === "failed") ? "failed" : "passed") !== input.status) throw new Error("Acceptance status does not match its checks");
-		const run = this.store.recordAcceptance(app.id, input);
-		this.options.emit("local_app.acceptance_recorded", {
-			appId: app.id,
-			sourceHash: run.sourceHash,
-			status: run.status
+		if ([...requiredIds].some((checkId) => !seenIds.has(checkId))) throw new LocalAppAcceptanceValidationError("Automatic acceptance must include every required check");
+		if ((input.checks.some((check) => check.status === "failed") ? "failed" : "passed") !== input.status) throw new LocalAppAcceptanceValidationError("Acceptance status does not match its checks");
+		if (input.status === "passed" && input.checks.some((check) => requiredIds.has(check.id) && check.status !== "passed" && !(check.id === "interaction" && check.status === "skipped" && input.interactiveCount === 0))) throw new LocalAppAcceptanceValidationError("Passed acceptance cannot skip required checks");
+		return runSqliteWriteTransaction((db) => {
+			const run = this.store.recordAcceptance(app.id, input);
+			db.prepare(`INSERT INTO domain_outbox
+        (event_id, event_type, subject_kind, subject_id, correlation_id, payload_json, created_at, operation_id)
+        VALUES (?, 'local_app.acceptance_recorded', 'local_app', ?, ?, ?, ?, ?)`).run(randomUUID(), app.id, run.id, JSON.stringify({
+				appId: app.id,
+				sourceHash: run.sourceHash,
+				status: run.status,
+				acceptanceId: run.id
+			}), run.createdAt, currentOperationId() ?? null);
+			afterSqliteCommit(() => this.flushAcceptanceEvents());
+			return run;
 		});
-		return run;
+	}
+	flushAcceptanceEvents() {
+		new DomainOutboxDispatcher((event) => this.options.emit(event.type, event.payload)).drain(100, "local_app");
 	}
 	releaseRoot(appId) {
 		return join(resolveStateDir(), "local-apps", "releases", appId);
@@ -369,18 +500,21 @@ var LocalAppService = class {
 		const staged = join(transactionRoot, input.app.extensionId);
 		const backup = join(transactionRoot, "previous");
 		const target = join(extensionsDir, input.app.extensionId);
-		cpSync(input.artifactPath, staged, {
-			recursive: true,
-			filter: shouldCopyReleasePath
-		});
 		let hadPrevious = false;
+		let targetInstalled = false;
+		let canCleanup = false;
 		let configSaved = false;
 		try {
+			cpSync(input.artifactPath, staged, {
+				recursive: true,
+				filter: shouldCopyReleasePath
+			});
 			if (existsSync(target)) {
 				renameSync(target, backup);
 				hadPrevious = true;
 			}
 			renameSync(staged, target);
+			targetInstalled = true;
 			validateLocalAppPackage(target, input.app.extensionId);
 			const saved = await this.options.saveConfig(input.nextConfig);
 			if (!saved.saved) throw new Error(saved.error ?? "Failed to update local app activation");
@@ -388,12 +522,14 @@ var LocalAppService = class {
 			this.refreshExtensions(input.source);
 			this.assertInstalledRuntime(input.app, target);
 			input.commit();
+			canCleanup = true;
 		} catch (error) {
-			if (existsSync(target)) rmSync(target, {
+			if (targetInstalled && existsSync(target)) rmSync(target, {
 				recursive: true,
 				force: true
 			});
 			if (hadPrevious && existsSync(backup)) renameSync(backup, target);
+			canCleanup = true;
 			if (configSaved) {
 				const restored = await this.options.saveConfig(previousConfig);
 				if (!restored.saved) log.error({
@@ -404,13 +540,13 @@ var LocalAppService = class {
 			this.refreshExtensions(`${input.source}-rollback`);
 			throw error;
 		} finally {
-			rmSync(transactionRoot, {
-				recursive: true,
-				force: true
-			});
+			if (canCleanup) cleanupReleaseStaging(transactionRoot);
 		}
 	}
 	async install(id) {
+		return this.mutateRelease(id, () => this.installRelease(id));
+	}
+	async installRelease(id) {
 		const app = this.store.get(id);
 		if (!app) throw new Error("Local app not found");
 		const releaseRoot = this.releaseRoot(app.id);
@@ -452,10 +588,7 @@ var LocalAppService = class {
 			});
 			throw error;
 		} finally {
-			rmSync(stagingRoot, {
-				recursive: true,
-				force: true
-			});
+			cleanupReleaseStaging(stagingRoot);
 		}
 		const next = this.get(id);
 		this.options.emit("local_app.installed", {
@@ -471,11 +604,15 @@ var LocalAppService = class {
 		return next;
 	}
 	async rollback(id, releaseId) {
+		return this.mutateRelease(id, () => this.rollbackRelease(id, releaseId));
+	}
+	async rollbackRelease(id, releaseId) {
 		const app = this.store.get(id);
 		if (!app) throw new Error("Local app not found");
 		const release = this.store.getRelease(id, releaseId);
 		if (!release || !release.artifactPath || !existsSync(release.artifactPath)) throw new Error("Local app release artifact is unavailable");
 		validateLocalAppPackage(release.artifactPath, app.extensionId);
+		if (hashDirectory(release.artifactPath) !== release.sourceHash) throw new Error("Release artifact integrity check failed; rollback was not applied");
 		await this.activateArtifact({
 			app,
 			artifactPath: release.artifactPath,
@@ -493,6 +630,9 @@ var LocalAppService = class {
 		return this.get(id);
 	}
 	async setEnabled(id, enabled) {
+		return this.mutateRelease(id, () => this.setReleaseEnabled(id, enabled));
+	}
+	async setReleaseEnabled(id, enabled) {
 		const app = this.store.get(id);
 		if (!app) throw new Error("Local app not found");
 		if (app.installationState !== "installed") throw new Error("Install the local app before changing its enabled state");
@@ -510,6 +650,9 @@ var LocalAppService = class {
 		return this.get(id);
 	}
 	async uninstall(id) {
+		return this.mutateRelease(id, () => this.uninstallRelease(id));
+	}
+	async uninstallRelease(id) {
 		const app = this.store.get(id);
 		if (!app) throw new Error("Local app not found");
 		const extensionsDir = resolveExtensionsDir();
@@ -519,6 +662,7 @@ var LocalAppService = class {
 		const backup = join(transactionRoot, app.extensionId);
 		const previousConfig = this.options.getConfig();
 		let moved = false;
+		let canCleanup = false;
 		let configSaved = false;
 		try {
 			if (existsSync(target)) {
@@ -529,17 +673,16 @@ var LocalAppService = class {
 			if (!saved.saved) throw new Error(saved.error ?? "Failed to uninstall local app");
 			configSaved = true;
 			this.store.markUninstalled(id);
-			this.refreshExtensions("local-app-uninstall");
+			canCleanup = true;
 		} catch (error) {
 			if (moved && existsSync(backup)) renameSync(backup, target);
+			canCleanup = true;
 			if (configSaved) await this.options.saveConfig(previousConfig);
 			throw error;
 		} finally {
-			rmSync(transactionRoot, {
-				recursive: true,
-				force: true
-			});
+			if (canCleanup) cleanupReleaseStaging(transactionRoot);
 		}
+		this.refreshExtensions("local-app-uninstall");
 		this.options.emit("local_app.uninstalled", {
 			appId: id,
 			projectId: app.projectId
@@ -548,4 +691,4 @@ var LocalAppService = class {
 	}
 };
 //#endregion
-export { LocalAppService };
+export { LocalAppAcceptanceValidationError, LocalAppRevisionConflictError, LocalAppService };

package/dist/src/local-apps/store.js

@@ -132,8 +132,6 @@ var LocalAppStore = class {
 	}
 	recordAcceptance(appId, input) {
 		const checksJson = JSON.stringify(input.checks);
-		const latest = this.listAcceptanceRuns(appId, 1)[0];
-		if (latest && latest.sourceHash === input.sourceHash && latest.status === input.status && latest.interactiveCount === input.interactiveCount && JSON.stringify(latest.checks) === checksJson) return latest;
 		const row = {
 			run_id: randomUUID(),
 			app_id: appId,

package/dist/src/mcp/capability-server.d.ts

@@ -0,0 +1,4 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { type GatewayHttpClient } from './gateway-http-client.js';
+/** An opt-in HTTP proxy, not a new principal or an approval authority. */
+export declare function createCapabilityMcpServer(client: Pick<GatewayHttpClient, 'getJson' | 'postJson'>, capabilityIds: readonly string[]): Server;

package/dist/src/mcp/capability-server.js

@@ -0,0 +1,96 @@
+import { PACKAGE_VERSION, init_package_version } from "../package-version.js";
+import { CapabilityCallSchema } from "../../packages/gateway-contract/src/capabilities.js";
+import { init_src } from "../../packages/gateway-contract/src/index.js";
+import { GatewayHttpError } from "./gateway-http-client.js";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+//#region src/mcp/capability-server.ts
+init_src();
+init_package_version();
+const BASE = "/api/capabilities/operations";
+/** An opt-in HTTP proxy, not a new principal or an approval authority. */
+function createCapabilityMcpServer(client, capabilityIds) {
+	if (!capabilityIds.length || capabilityIds.some((id) => !/^xopc\.[a-z0-9_.]+$/.test(id))) throw new Error("At least one explicit xopc capability ID is required (wildcards are not supported)");
+	const allowed = new Set(capabilityIds);
+	const server = new Server({
+		name: "xopc-capabilities",
+		version: PACKAGE_VERSION
+	}, { capabilities: { tools: {} } });
+	const catalog = async () => {
+		return (await client.getJson(BASE)).capabilities.filter((item) => allowed.has(item.id) && item.surfaces.includes("http"));
+	};
+	server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: (await catalog()).map((item) => ({
+		name: item.id,
+		description: `${item.description}\nGateway HTTP proxy. Use the discovered contract unchanged. Writes require a stable idempotencyKey; never retry an uncertain write with a new key.`,
+		inputSchema: {
+			type: "object",
+			additionalProperties: false,
+			required: [
+				"majorVersion",
+				"descriptorDigest",
+				"input",
+				...item.effect === "read" ? [] : ["idempotencyKey"]
+			],
+			properties: {
+				majorVersion: {
+					type: "integer",
+					const: item.majorVersion
+				},
+				descriptorDigest: {
+					type: "string",
+					const: item.descriptorDigest
+				},
+				input: item.inputSchema,
+				idempotencyKey: {
+					type: "string",
+					minLength: 1,
+					maxLength: 200
+				}
+			}
+		},
+		annotations: {
+			readOnlyHint: item.effect === "read",
+			destructiveHint: item.effect === "destructive",
+			openWorldHint: true
+		}
+	})) }));
+	server.setRequestHandler(CallToolRequestSchema, async ({ params }) => {
+		const fail = (code, operationId) => ({
+			isError: true,
+			content: [{
+				type: "text",
+				text: JSON.stringify({
+					code,
+					...operationId ? { operationId } : {}
+				})
+			}]
+		});
+		if (!allowed.has(params.name)) return fail("FORBIDDEN");
+		const parsed = CapabilityCallSchema.safeParse(params.arguments);
+		if (!parsed.success) return fail("INVALID_INPUT");
+		let dispatched = false;
+		let write = false;
+		try {
+			const descriptor = (await catalog()).find((item) => item.id === params.name);
+			if (!descriptor) return fail("FORBIDDEN");
+			if (parsed.data.majorVersion !== descriptor.majorVersion || parsed.data.descriptorDigest !== descriptor.descriptorDigest) return fail("CONTRACT_CHANGED");
+			write = descriptor.effect !== "read";
+			if (write && !parsed.data.idempotencyKey) return fail("INVALID_INPUT");
+			dispatched = true;
+			const result = await client.postJson(`${BASE}/${encodeURIComponent(params.name)}/invocations`, parsed.data);
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify(result)
+				}],
+				structuredContent: result
+			};
+		} catch (error) {
+			if (error instanceof GatewayHttpError) return fail(error.code ?? (error.status === 401 || error.status === 403 ? "FORBIDDEN" : dispatched && write ? "OUTCOME_UNKNOWN" : "UNAVAILABLE"), error.operationId);
+			return fail(dispatched && write ? "OUTCOME_UNKNOWN" : "UNAVAILABLE");
+		}
+	});
+	return server;
+}
+//#endregion
+export { createCapabilityMcpServer };

package/dist/src/mcp/channel-bridge.js

@@ -1,9 +1,9 @@
 import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
 import { init_loader, loadConfig } from "../config/loader.js";
+import { createGatewayHttpClientFromConfig, resolveGatewayHttpBaseUrl } from "./gateway-http-client.js";
 import { RealtimeClient } from "../../packages/realtime-client/src/index.js";
 import { toConversation } from "./channel-shared.js";
-import { createGatewayHttpClientFromConfig, resolveGatewayHttpBaseUrl } from "./gateway-http-client.js";
 import { createRequire } from "node:module";
 import crypto from "node:crypto";
 //#region src/mcp/channel-bridge.ts

package/dist/src/mcp/gateway-http-client.d.ts

@@ -1,5 +1,12 @@
+import { type CapabilityErrorCode } from '@xopcai/gateway-contract';
 import type { Config } from '../config/schema.js';
 import { type GatewayCredential } from '../gateway/credential.js';
+export declare class GatewayHttpError extends Error {
+    readonly status: number;
+    readonly code?: CapabilityErrorCode;
+    readonly operationId?: string;
+    constructor(status: number, code?: CapabilityErrorCode, operationId?: string);
+}
 export type GatewayHttpClientOptions = {
     baseUrl: string;
     credential?: GatewayCredential;