@alfe.ai/integrations 0.1.0 → 0.1.2

package/dist/index.d.ts

@@ -293,19 +293,16 @@ declare class McpApplier {
    * (the manager preserves `addedAt`). Returns the list of ids that
    * actually landed in the store.
    *
-   * Awaits `manager.flush()` before returning so the openclaw.json
-   * mirror write has fired by the time the caller proceeds. Without
-   * this, an integration activation's success ack would race ahead of
-   * the runtime's openclaw.json update — the cloud would see
-   * `actual.status = active` while OpenClaw still has the stale MCP
-   * set in memory, violating the actual-status protocol contract.
+   * Store writes are durable before each `manager.addServer` resolves,
+   * so the caller can ack the activation as soon as this returns —
+   * the daemon-hosted bundler will pick the change up via the store
+   * watcher and reconcile its children.
    */
   applyForIntegration(integrationId: string, servers: McpServerDeclaration[], mergedConfig: Record<string, unknown>): Promise<string[]>;
   /**
-   * Drop every entry owned by this integration. Like `applyForIntegration`,
-   * awaits the mirror flush so the runtime is signalled before the call
-   * resolves — the uninstall ack shouldn't outrun openclaw.json being
-   * cleaned up.
+   * Drop every entry owned by this integration. Store writes are
+   * durable before `removeServersByOwner` resolves; the daemon's
+   * bundler reconciles via the store watcher.
    */
   removeForIntegration(integrationId: string): Promise<string[]>;
   private resolveEnv;

package/dist/index.js

@@ -1162,6 +1162,13 @@ var IntegrationManager = class {
 		this.log.info(`Deactivating integration: ${integrationId}`);
 		try {
 			const removed = this.lockManager.removeEntries(integrationId);
+			const remaining = this.lockManager.read();
+			const claimedPluginsByRuntime = /* @__PURE__ */ new Map();
+			const claimedSkillsByRuntime = /* @__PURE__ */ new Map();
+			for (const [rtName, state] of Object.entries(remaining.runtimes)) {
+				claimedPluginsByRuntime.set(rtName, new Set(state.plugins.map((p) => p.package)));
+				claimedSkillsByRuntime.set(rtName, new Set(state.skills.map((s) => s.name)));
+			}
 			for (const [runtimeName, entries] of Object.entries(removed)) {
 				const applier = this.runtimeAppliers.get(runtimeName);
 				if (!applier) {
@@ -1172,7 +1179,13 @@ var IntegrationManager = class {
 					this.log.warn(`Runtime "${runtimeName}" is not available — skipping removal`);
 					continue;
 				}
+				const keepPlugins = claimedPluginsByRuntime.get(runtimeName) ?? /* @__PURE__ */ new Set();
+				const keepSkills = claimedSkillsByRuntime.get(runtimeName) ?? /* @__PURE__ */ new Set();
 				for (const plugin of entries.plugins) {
+					if (keepPlugins.has(plugin.package)) {
+						this.log.info(`Keeping plugin ${plugin.package} on ${runtimeName} — still claimed by another active integration`);
+						continue;
+					}
 					this.log.info(`Removing plugin ${plugin.package} from ${runtimeName}`);
 					try {
 						await applier.removePlugin(plugin.package);
@@ -1181,6 +1194,10 @@ var IntegrationManager = class {
 					}
 				}
 				for (const skill of entries.skills) {
+					if (keepSkills.has(skill.name)) {
+						this.log.info(`Keeping skill ${skill.name} on ${runtimeName} — still claimed by another active integration`);
+						continue;
+					}
 					this.log.info(`Removing skill ${skill.name} from ${runtimeName}`);
 					try {
 						if (skill.sourcePath.startsWith("clawhub:")) await applier.removeClawHubSkill(skill.name);
@@ -1901,12 +1918,10 @@ var McpApplier = class {
 	* (the manager preserves `addedAt`). Returns the list of ids that
 	* actually landed in the store.
 	*
-	* Awaits `manager.flush()` before returning so the openclaw.json
-	* mirror write has fired by the time the caller proceeds. Without
-	* this, an integration activation's success ack would race ahead of
-	* the runtime's openclaw.json update — the cloud would see
-	* `actual.status = active` while OpenClaw still has the stale MCP
-	* set in memory, violating the actual-status protocol contract.
+	* Store writes are durable before each `manager.addServer` resolves,
+	* so the caller can ack the activation as soon as this returns —
+	* the daemon-hosted bundler will pick the change up via the store
+	* watcher and reconcile its children.
 	*/
 	async applyForIntegration(integrationId, servers, mergedConfig) {
 		const owner = `integration:${integrationId}`;
@@ -1928,20 +1943,16 @@ var McpApplier = class {
 			});
 			applied.push(id);
 		}
-		await this.manager.flush();
 		return applied;
 	}
 	/**
-	* Drop every entry owned by this integration. Like `applyForIntegration`,
-	* awaits the mirror flush so the runtime is signalled before the call
-	* resolves — the uninstall ack shouldn't outrun openclaw.json being
-	* cleaned up.
+	* Drop every entry owned by this integration. Store writes are
+	* durable before `removeServersByOwner` resolves; the daemon's
+	* bundler reconciles via the store watcher.
 	*/
 	async removeForIntegration(integrationId) {
 		const owner = `integration:${integrationId}`;
-		const removed = await this.manager.removeServersByOwner(owner);
-		await this.manager.flush();
-		return removed;
+		return this.manager.removeServersByOwner(owner);
 	}
 	async resolveEnv(server, mergedConfig) {
 		if (!server.env || Object.keys(server.env).length === 0) return {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alfe.ai/integrations",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Integration lifecycle management for Alfe — registry, resolution, installation, and state",
   "type": "module",
   "main": "./dist/index.js",
@@ -13,8 +13,8 @@
   },
   "dependencies": {
     "@auriclabs/logger": "^0.1.1",
-    "@alfe.ai/integration-manifest": "^0.1.0",
-    "@alfe.ai/mcp-bundler": "^0.1.0"
+    "@alfe.ai/integration-manifest": "^0.2.0",
+    "@alfe.ai/mcp-bundler": "^0.2.0"
   },
   "files": [
     "dist"