@alfe.ai/integrations 0.2.6 → 0.2.7

package/dist/index.d.ts

@@ -951,6 +951,16 @@ declare class OpenClawApplier implements RuntimeApplier {
    * plugins under 2026.5+, which made force-mode skip its uninstall step.
    */
   private isPluginInstalled;
+  /**
+   * Best-effort read of the installed version of a plugin, or `undefined` when
+   * it can't be determined. Reads the version from the installed package's
+   * package.json under the npm registry path OpenClaw 2026.5+ installs to
+   * (`~/.openclaw/npm/node_modules/<pkg>/package.json`) — the same root
+   * `isPluginInstalled` checks. 2026.4 extensions-dir installs have no
+   * stable package.json version here and return `undefined` (callers fail
+   * open to the safe reinstall path).
+   */
+  private installedPluginVersion;
   /**
    * Remove an extensions/ install that has no matching record in
    * plugins/installs.json. OpenClaw 2026.5+ tracks installs via the records

package/dist/index.js

@@ -856,6 +856,22 @@ function stripPluginVersion(spec) {
 	if (at <= 0) return spec;
 	return spec.slice(0, at);
 }
+/**
+* Return the pinned version from a plugin spec, or `undefined` when the spec
+* carries no version (bare package name). Mirror of `stripPluginVersion`: the
+* version is everything after the LAST '@' when that '@' sits at index > 0
+* (i.e. it's a real version delimiter, not the scope's leading '@').
+*
+* Used by the force-mode reinstall path to compare the pinned version against
+* the installed one so an already-current plugin can skip a ~45s
+* uninstall+reinstall cycle.
+*/
+function pluginSpecVersion(spec) {
+	const at = spec.lastIndexOf("@");
+	if (at <= 0) return void 0;
+	const version = spec.slice(at + 1);
+	return version.length > 0 ? version : void 0;
+}
 //#endregion
 //#region src/integration-manager.ts
 /**
@@ -1729,6 +1745,15 @@ const BUNDLED_BASELINE_ALLOW = ["browser"];
 const CONFIG_SET_RETRIES$1 = 3;
 const CONFIG_SET_RETRY_DELAY_MS$1 = 750;
 /**
+* Max `openclaw config get` spawns in flight at once during the batch
+* verify-after-write. A naive `Promise.all(leaves.map(...))` fires one CLI
+* process per leaf simultaneously — a 36-leaf model-provider batch on a 2-vCPU
+* box means 36 concurrent `config get`s, each needing ~1.9s of CPU, so every
+* process blows its own 10s timeout and the verify reports false even when the
+* write actually landed. A small pool keeps the read-backs honest under load.
+*/
+const VERIFY_GET_CONCURRENCY = 4;
+/**
 * Sentinel OpenClaw returns from `config get` in place of a sensitive value —
 * the key IS set, OpenClaw is just hiding it. Verify-after-write must treat a
 * read-back of this as "present/matches" rather than a mismatch (see
@@ -1739,6 +1764,29 @@ const delay$1 = (ms) => new Promise((resolve) => {
 	setTimeout(resolve, ms);
 });
 /**
+* Run `fn` over `items` with at most `limit` invocations in flight at once,
+* preserving result order. A tiny local pool (no new dependency) so the batch
+* verify-after-write doesn't stampede one `openclaw config get` per leaf — see
+* VERIFY_GET_CONCURRENCY.
+*
+* NOTE: relies on `fn` never rejecting (configValueMatches catches internally).
+* A throwing `fn` would reject the pool while sibling workers keep draining
+* items in the background — don't wire a throwing `fn` in here.
+*/
+async function mapWithConcurrency(items, limit, fn) {
+	const results = new Array(items.length);
+	let cursor = 0;
+	const worker = async () => {
+		while (cursor < items.length) {
+			const index = cursor++;
+			results[index] = await fn(items[index]);
+		}
+	};
+	const workers = Array.from({ length: Math.min(limit, items.length) }, () => worker());
+	await Promise.all(workers);
+	return results;
+}
+/**
 * Asymmetric structural containment for verify-after-write: is every field we
 * INTENDED present in the ACTUAL read-back with our value? `actual` may carry
 * EXTRA keys that `intended` does not.
@@ -1781,19 +1829,70 @@ function deepSubset(intended, actual) {
 function redactConfigSetTarget(args) {
 	return `openclaw config ${args.slice(0, 2).join(" ")}`.trim();
 }
+/** Cap a captured stream so a runaway OpenClaw dump can't bloat errorMessage. */
+const ERROR_STREAM_MAX = 400;
+function truncateForError(s) {
+	return s.length > ERROR_STREAM_MAX ? `${s.slice(0, ERROR_STREAM_MAX)}… (truncated)` : s;
+}
+/**
+* Collect the value strings a `config set` argv carries so they can be scrubbed
+* out of OpenClaw's own output. OpenClaw validation errors can echo the
+* offending VALUE back in their diagnostic text, so stdout/stderr must be
+* treated as value-bearing, not just the argv. For `{path, value}` batch
+* entries only the `value` side is collected — redacting the path out of
+* "invalid path models.providers…" would gut the diagnostic.
+*/
+function collectArgvValues(args) {
+	const out = [];
+	const collect = (v) => {
+		if (typeof v === "string") {
+			if (v.length >= 4) out.push(v);
+		} else if (Array.isArray(v)) v.forEach(collect);
+		else if (v !== null && typeof v === "object") {
+			const o = v;
+			if (typeof o.path === "string" && "value" in o) collect(o.value);
+			else Object.values(o).forEach(collect);
+		}
+	};
+	for (const token of args.slice(2)) {
+		if (token.startsWith("--")) continue;
+		try {
+			collect(JSON.parse(token));
+		} catch {
+			collect(token);
+		}
+	}
+	return out.sort((a, b) => b.length - a.length);
+}
+/** Replace every occurrence of the argv-derived values in a captured stream. */
+function scrubStream(s, values) {
+	let out = s;
+	for (const v of values) if (out.includes(v)) out = out.split(v).join("[REDACTED]");
+	return out;
+}
 /**
 * 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).
+* redacted target, the exit code, `stderr`, and `stdout`.
+*
+* OpenClaw prints its own error text to STDOUT (not stderr), so on a genuine
+* failure `stderr` is often empty and the real cause is in stdout — surfacing
+* only stderr left days of bare "(exit 1)" in the logs. We include a truncated
+* stdout too — but scrubbed first: OpenClaw's error text can echo the offending
+* value, so both streams are run through `scrubStream` with the argv values
+* before anything reaches the dashboard-visible errorMessage.
 */
 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 values = collectArgvValues(args);
+		const stderr = typeof e.stderr === "string" ? scrubStream(e.stderr.trim(), values) : "";
+		const stdout = typeof e.stdout === "string" ? scrubStream(e.stdout.trim(), values) : "";
 		const code = e.code !== void 0 ? ` (exit ${e.code})` : "";
-		return stderr ? `${target} failed${code}: ${stderr}` : `${target} failed${code}`;
+		const details = [stderr, stdout ? `stdout: ${truncateForError(stdout)}` : ""].filter(Boolean).join("; ");
+		return details ? `${target} failed${code}: ${details}` : `${target} failed${code}`;
 	}
 	return `${target} failed: ${String(err)}`;
 }
@@ -1919,9 +2018,21 @@ var OpenClawApplier = class {
 		await this.ensurePluginsAllowUnlocked(pkg);
 		this.cleanupUntrackedExtensionInstall(pkg);
 		if (opts?.force && this.isPluginInstalled(pkg)) {
+			const pinnedVersion = pluginSpecVersion(spec);
+			const installedVersion = this.installedPluginVersion(pkg);
+			if (pinnedVersion && installedVersion && installedVersion === pinnedVersion) {
+				log$3.info({
+					pkg,
+					spec,
+					version: installedVersion
+				}, "Force mode — installed version already matches pinned spec, skipping uninstall+reinstall");
+				return;
+			}
 			log$3.info({
 				pkg,
-				spec
+				spec,
+				installedVersion,
+				pinnedVersion
 			}, "Force mode — uninstalling plugin before reinstall");
 			try {
 				await this.removePluginUnlocked(pkg);
@@ -2039,6 +2150,25 @@ var OpenClawApplier = class {
 		return readdirSync(extensionsDir).some((dir) => dir.startsWith(prefix) && /^[0-9a-f]+$/i.test(dir.slice(prefix.length)));
 	}
 	/**
+	* Best-effort read of the installed version of a plugin, or `undefined` when
+	* it can't be determined. Reads the version from the installed package's
+	* package.json under the npm registry path OpenClaw 2026.5+ installs to
+	* (`~/.openclaw/npm/node_modules/<pkg>/package.json`) — the same root
+	* `isPluginInstalled` checks. 2026.4 extensions-dir installs have no
+	* stable package.json version here and return `undefined` (callers fail
+	* open to the safe reinstall path).
+	*/
+	installedPluginVersion(pkg) {
+		const pkgJsonPath = join(this.home, "npm", "node_modules", ...pkg.split("/"), "package.json");
+		if (!existsSync(pkgJsonPath)) return void 0;
+		try {
+			const data = JSON.parse(readFileSync(pkgJsonPath, "utf8"));
+			return typeof data.version === "string" ? data.version : void 0;
+		} catch {
+			return;
+		}
+	}
+	/**
 	* Remove an extensions/ install that has no matching record in
 	* plugins/installs.json. OpenClaw 2026.5+ tracks installs via the records
 	* file — a leftover dir from 2026.4 is invisible to `openclaw plugins
@@ -2192,10 +2322,10 @@ var OpenClawApplier = class {
 				"--batch-json",
 				JSON.stringify(leaves),
 				"--replace"
-			]);
+			], { timeout: Math.min(Math.max(3e4, leaves.length * 2e3), 12e4) });
 		} catch (err) {
 			if (await this.verifyApplied(async () => {
-				return (await Promise.all(leaves.map((l) => this.configValueMatches(l.path, l.value)))).every(Boolean);
+				return (await mapWithConcurrency(leaves, VERIFY_GET_CONCURRENCY, (l) => this.configValueMatches(l.path, l.value))).every(Boolean);
 			})) log$3.warn({ count: leaves.length }, "openclaw config set --batch-json exited non-zero but config landed — continuing");
 			else {
 				log$3.error({

package/package.json

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