@alfe.ai/integrations 0.1.5 → 0.1.6

package/dist/index.d.ts

@@ -287,6 +287,13 @@ interface RuntimeApplier {
   applyPlugin(pkg: string, integrationInstallPath: string, opts?: {
     force?: boolean;
   }): Promise<void>;
+  /**
+   * Optional: pre-trust an integration's full plugin set in one write before
+   * the per-plugin install loop. Runtimes whose config writes trigger a reload
+   * (OpenClaw) implement this to collapse N allowlist writes into one. Absent
+   * → the manager relies on `applyPlugin` to allowlist each plugin itself.
+   */
+  ensurePluginsAllowed?(pkgs: string[]): Promise<void>;
   /** Remove a plugin package from this runtime */
   removePlugin(pkg: string): Promise<void>;
   /** Copy a skill directory into this runtime's skills location */
@@ -748,6 +755,10 @@ interface OpenClawApplierOptions {
   skillsDir?: string;
   /** Path to the integration tracking file (defaults to {home}/config.json) */
   configPath?: string;
+  /** Max retries for a transient `openclaw config set` failure (default 3) */
+  configSetRetries?: number;
+  /** Backoff between `openclaw config set` retries, ms (default 750; set 0 in tests) */
+  configSetRetryDelayMs?: number;
 }
 declare class OpenClawApplier implements RuntimeApplier {
   readonly runtime = "openclaw";
@@ -755,15 +766,44 @@ declare class OpenClawApplier implements RuntimeApplier {
   private agentWorkspace;
   private skillsDir;
   private trackingPath;
+  private configSetRetries;
+  private configSetRetryDelayMs;
+  /** Serializes all `openclaw config set` writes so they never interleave with each other or the hot-reload they trigger. */
+  private configSetQueue;
   constructor(options: OpenClawApplierOptions);
+  /** Convenience: `openclaw config set <args>`, serialized + retried. */
+  private runConfigSet;
+  /**
+   * Run `openclaw config <args>` (set/unset), serialized against every other
+   * config write and retried with backoff. See CONFIG_SET_RETRIES for why:
+   * each write triggers a runtime hot-reload that rewrites openclaw.json, and a
+   * follow-up command that races the reload fails with a bare "Command failed".
+   *
+   * Throws an Error whose (scrubbed) message includes stderr after retries are
+   * exhausted, so the real cause propagates to the integration errorMessage
+   * without leaking the value payload.
+   */
+  private runConfigCommand;
   applyPlugin(spec: string, _installPath?: string, opts?: {
     force?: boolean;
   }): Promise<void>;
   /**
-   * Ensure the plugin is in plugins.allow in openclaw.json.
+   * Ensure one or more plugins are in plugins.allow in openclaw.json.
    * Uses `openclaw config set` to avoid clobbering OpenClaw's own file format.
+   *
+   * Prefer passing the FULL set of plugins for an integration in a single call
+   * (see `ensurePluginsAllowed`): each write triggers a runtime hot-reload, so
+   * one write for N plugins is one reload instead of N.
    */
   private ensurePluginsAllow;
+  /**
+   * Pre-trust every plugin an integration ships in a SINGLE plugins.allow
+   * write, before any are installed. Called once by the manager ahead of the
+   * per-plugin install loop so activation triggers one hot-reload for the
+   * allowlist instead of one per plugin. `applyPlugin`'s own per-plugin
+   * `ensurePluginsAllow` then finds nothing missing and is a no-op.
+   */
+  ensurePluginsAllowed(specs: string[]): Promise<void>;
   /**
    * Check if a plugin is already installed.
    *

package/dist/index.js

@@ -1113,7 +1113,7 @@ var IntegrationManager = class {
 				message: "Already active"
 			}
 		};
-		if (entry.status !== "configured" && entry.status !== "installed") return this.err("INVALID_STATE", `Cannot activate integration in "${entry.status}" state`);
+		if (entry.status !== "configured" && entry.status !== "installed" && entry.status !== "error") return this.err("INVALID_STATE", `Cannot activate integration in "${entry.status}" state`);
 		this.log.info(`Activating integration: ${integrationId}`);
 		try {
 			const installPath = this.installer.getInstallPath(integrationId);
@@ -1136,6 +1136,11 @@ var IntegrationManager = class {
 					continue;
 				}
 				const { plugins, skills, config: runtimeConfig } = resolveInstallsForRuntime(manifest, runtimeName);
+				if (applier.ensurePluginsAllowed && plugins.length > 0) try {
+					await applier.ensurePluginsAllowed(plugins.map((p) => p.package));
+				} catch (err) {
+					this.log.warn(`Failed to pre-trust plugins for ${integrationId} on ${runtimeName}: ${err instanceof Error ? err.message : String(err)}`);
+				}
 				const pluginFailures = [];
 				for (const plugin of plugins) {
 					this.log.info(`Applying plugin ${plugin.package} to ${runtimeName}`);
@@ -1613,6 +1618,45 @@ const DEFAULT_SKILLS_DIR = join(homedir(), ".alfe", "skills");
 * LLM/voice traffic through its own AI proxy, so leaving them gated off is correct.
 */
 const BUNDLED_BASELINE_ALLOW = ["browser"];
+/**
+* Every `openclaw config set` triggers an async hot-reload of the running
+* OpenClaw runtime, which itself rewrites openclaw.json. If the next
+* `config set` fires before that reload settles it collides with the
+* in-flight write (OpenClaw's clobber protection) and exits non-zero with a
+* bare "Command failed". We serialize all config writes through one promise
+* chain and retry transient failures with a short backoff so the reload has
+* time to settle between writes.
+*/
+const CONFIG_SET_RETRIES = 3;
+const CONFIG_SET_RETRY_DELAY_MS = 750;
+const delay = (ms) => new Promise((resolve) => {
+	setTimeout(resolve, ms);
+});
+/**
+* Describe a `config set` target WITHOUT leaking values. The value argument is
+* the JSON payload (model config, the gateway loopback token via the alfe hook,
+* etc.) and must never reach the integration's `errorMessage`, which projects
+* to the user-facing dashboard. Keep only the program + the path/flag.
+*/
+function redactConfigSetTarget(args) {
+	return `openclaw config ${args.slice(0, 2).join(" ")}`.trim();
+}
+/**
+* Build a diagnosable BUT scrubbed message from an execFile rejection. Node's
+* execFile error `message` is "Command failed: <full argv>" — which for
+* `config set` embeds the value payload — so we never surface it. We keep the
+* redacted target, the exit code, and `stderr` (openclaw's own error text).
+*/
+function configSetErrorMessage(err, args) {
+	const target = redactConfigSetTarget(args);
+	if (err instanceof Error) {
+		const e = err;
+		const stderr = typeof e.stderr === "string" ? e.stderr.trim() : "";
+		const code = e.code !== void 0 ? ` (exit ${e.code})` : "";
+		return stderr ? `${target} failed${code}: ${stderr}` : `${target} failed${code}`;
+	}
+	return `${target} failed: ${String(err)}`;
+}
 function flattenConfig(obj, prefix = "") {
 	const entries = [];
 	for (const [key, val] of Object.entries(obj)) {
@@ -1677,6 +1721,10 @@ var OpenClawApplier = class {
 	agentWorkspace;
 	skillsDir;
 	trackingPath;
+	configSetRetries;
+	configSetRetryDelayMs;
+	/** Serializes all `openclaw config set` writes so they never interleave with each other or the hot-reload they trigger. */
+	configSetQueue = Promise.resolve();
 	constructor(options) {
 		const home = options.home ?? options.workspace;
 		if (!home) throw new Error("OpenClawApplier requires `home` (or legacy `workspace`) option");
@@ -1684,6 +1732,39 @@ var OpenClawApplier = class {
 		this.agentWorkspace = options.agentWorkspace ?? join(home, "workspace");
 		this.skillsDir = options.skillsDir ?? DEFAULT_SKILLS_DIR;
 		this.trackingPath = options.configPath ?? join(this.home, "config.json");
+		this.configSetRetries = options.configSetRetries ?? CONFIG_SET_RETRIES;
+		this.configSetRetryDelayMs = options.configSetRetryDelayMs ?? CONFIG_SET_RETRY_DELAY_MS;
+	}
+	/** Convenience: `openclaw config set <args>`, serialized + retried. */
+	runConfigSet(setArgs, opts = {}) {
+		return this.runConfigCommand(["set", ...setArgs], opts);
+	}
+	/**
+	* Run `openclaw config <args>` (set/unset), serialized against every other
+	* config write and retried with backoff. See CONFIG_SET_RETRIES for why:
+	* each write triggers a runtime hot-reload that rewrites openclaw.json, and a
+	* follow-up command that races the reload fails with a bare "Command failed".
+	*
+	* Throws an Error whose (scrubbed) message includes stderr after retries are
+	* exhausted, so the real cause propagates to the integration errorMessage
+	* without leaking the value payload.
+	*/
+	runConfigCommand(args, opts = {}) {
+		const timeout = opts.timeout ?? 1e4;
+		const run = async () => {
+			let lastErr;
+			for (let attempt = 0; attempt <= this.configSetRetries; attempt++) try {
+				await execFileAsync("openclaw", ["config", ...args], { timeout });
+				return;
+			} catch (err) {
+				lastErr = err;
+				if (attempt < this.configSetRetries && this.configSetRetryDelayMs > 0) await delay(this.configSetRetryDelayMs * 2 ** attempt);
+			}
+			throw new Error(configSetErrorMessage(lastErr, args));
+		};
+		const result = this.configSetQueue.then(run, run);
+		this.configSetQueue = result.catch(() => void 0);
+		return result;
 	}
 	async applyPlugin(spec, _installPath, opts) {
 		const pkg = stripPluginVersion(spec);
@@ -1740,10 +1821,15 @@ var OpenClawApplier = class {
 		}
 	}
 	/**
-	* Ensure the plugin is in plugins.allow in openclaw.json.
+	* Ensure one or more plugins are in plugins.allow in openclaw.json.
 	* Uses `openclaw config set` to avoid clobbering OpenClaw's own file format.
+	*
+	* Prefer passing the FULL set of plugins for an integration in a single call
+	* (see `ensurePluginsAllowed`): each write triggers a runtime hot-reload, so
+	* one write for N plugins is one reload instead of N.
 	*/
-	async ensurePluginsAllow(pkg) {
+	async ensurePluginsAllow(pkgs) {
+		const wanted = Array.isArray(pkgs) ? pkgs : [pkgs];
 		let currentAllow = [];
 		try {
 			const { stdout } = await execFileAsync("openclaw", [
@@ -1754,24 +1840,30 @@ var OpenClawApplier = class {
 			const parsed = JSON.parse(stdout.trim());
 			if (Array.isArray(parsed)) currentAllow = parsed;
 		} catch {}
-		const missing = [...new Set([pkg, ...BUNDLED_BASELINE_ALLOW])].filter((id) => !currentAllow.includes(id));
+		const missing = [...new Set([...wanted, ...BUNDLED_BASELINE_ALLOW])].filter((id) => !currentAllow.includes(id));
 		if (missing.length === 0) return;
 		const updated = [...currentAllow, ...missing];
 		try {
-			await execFileAsync("openclaw", [
-				"config",
-				"set",
-				"plugins.allow",
-				JSON.stringify(updated)
-			], { timeout: 1e4 });
+			await this.runConfigSet(["plugins.allow", JSON.stringify(updated)]);
 		} catch (err) {
 			log$1.warn({
 				err: err instanceof Error ? err.message : String(err),
-				pkg
+				pkgs: wanted
 			}, "Failed to set plugins.allow via openclaw config set");
 		}
 	}
 	/**
+	* Pre-trust every plugin an integration ships in a SINGLE plugins.allow
+	* write, before any are installed. Called once by the manager ahead of the
+	* per-plugin install loop so activation triggers one hot-reload for the
+	* allowlist instead of one per plugin. `applyPlugin`'s own per-plugin
+	* `ensurePluginsAllow` then finds nothing missing and is a no-op.
+	*/
+	async ensurePluginsAllowed(specs) {
+		if (specs.length === 0) return;
+		await this.ensurePluginsAllow(specs.map(stripPluginVersion));
+	}
+	/**
 	* Check if a plugin is already installed.
 	*
 	* OpenClaw 2026.4 stored plugins under `~/.openclaw/extensions/{pkg-name-with-dashes}-{hash}`.
@@ -1902,12 +1994,7 @@ var OpenClawApplier = class {
 			const merged = { ...await readParentObject(parentPath) };
 			for (const [k, v] of dottedKvs) merged[k] = v;
 			try {
-				await execFileAsync("openclaw", [
-					"config",
-					"set",
-					parentPath,
-					JSON.stringify(merged)
-				], { timeout: 1e4 });
+				await this.runConfigSet([parentPath, JSON.stringify(merged)]);
 			} catch (err) {
 				log$1.error({
 					err: err instanceof Error ? err.message : String(err),
@@ -1917,12 +2004,7 @@ var OpenClawApplier = class {
 			}
 		}
 		if (leaves.length > 0) try {
-			await execFileAsync("openclaw", [
-				"config",
-				"set",
-				"--batch-json",
-				JSON.stringify(leaves)
-			], { timeout: 1e4 });
+			await this.runConfigSet(["--batch-json", JSON.stringify(leaves)]);
 		} catch (err) {
 			log$1.error({
 				err: err instanceof Error ? err.message : String(err),
@@ -1944,11 +2026,7 @@ var OpenClawApplier = class {
 		const integrationConfig = integrations[integrationId];
 		const { leaves, subtreesByParent } = partitionEntries(flattenConfig(integrationConfig));
 		for (const { path } of leaves) try {
-			await execFileAsync("openclaw", [
-				"config",
-				"unset",
-				path
-			], { timeout: 1e4 });
+			await this.runConfigCommand(["unset", path]);
 		} catch (err) {
 			log$1.warn({
 				err: err instanceof Error ? err.message : String(err),
@@ -1960,17 +2038,8 @@ var OpenClawApplier = class {
 			const remaining = Object.fromEntries(Object.entries(existing).filter(([k]) => !dottedKvs.has(k)));
 			if (Object.keys(existing).length === 0) continue;
 			try {
-				if (Object.keys(remaining).length === 0) await execFileAsync("openclaw", [
-					"config",
-					"unset",
-					parentPath
-				], { timeout: 1e4 });
-				else await execFileAsync("openclaw", [
-					"config",
-					"set",
-					parentPath,
-					JSON.stringify(remaining)
-				], { timeout: 1e4 });
+				if (Object.keys(remaining).length === 0) await this.runConfigCommand(["unset", parentPath]);
+				else await this.runConfigSet([parentPath, JSON.stringify(remaining)]);
 			} catch (err) {
 				log$1.warn({
 					err: err instanceof Error ? err.message : String(err),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alfe.ai/integrations",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "description": "Integration lifecycle management for Alfe — registry, resolution, installation, and state",
   "type": "module",
   "main": "./dist/index.js",