@alfe.ai/integrations 0.2.0 → 0.2.1

package/dist/index.d.ts

@@ -796,6 +796,26 @@ declare class OpenClawApplier implements RuntimeApplier {
    * without leaking the value payload.
    */
   private runConfigCommand;
+  /**
+   * Read back a single config path and compare it to the value we tried to
+   * write. Used by `applyConfig`'s verify-after-write: a `config set` can exit
+   * non-zero (a hot-reload races the write, OpenClaw's clobber protection
+   * fires) even though the value actually landed, exactly like `applyPlugin`'s
+   * install-then-check tolerance.
+   *
+   * OpenClaw REDACTS sensitive values on `config get`, returning the literal
+   * `__OPENCLAW_REDACTED__` instead of the real value. Treat that as a match:
+   * the key exists and OpenClaw is hiding it, so a deep-equal against the
+   * intended value would otherwise be a false negative and force a re-throw.
+   */
+  private configValueMatches;
+  /**
+   * Run a read-back `check` with the same retry/backoff cadence as the config
+   * writes — the settling hot-reload may still be rewriting openclaw.json when
+   * we first read back, so a single check can be a false negative. Returns true
+   * on the first success, false once all attempts are exhausted.
+   */
+  private verifyApplied;
   applyPlugin(spec: string, _installPath?: string, opts?: {
     force?: boolean;
   }): Promise<void>;

package/dist/index.js

@@ -1702,10 +1702,40 @@ const BUNDLED_BASELINE_ALLOW = ["browser"];
 */
 const CONFIG_SET_RETRIES$1 = 3;
 const CONFIG_SET_RETRY_DELAY_MS$1 = 750;
+/**
+* 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
+* `configValueMatches`).
+*/
+const OPENCLAW_REDACTED = "__OPENCLAW_REDACTED__";
 const delay$1 = (ms) => new Promise((resolve) => {
 	setTimeout(resolve, ms);
 });
 /**
+* Structural equality for config read-back comparison. Primitives compare by
+* `Object.is`; arrays are order-SENSITIVE (config arrays are positional);
+* plain objects are order-INSENSITIVE (key order in JSON is not meaningful).
+* Used only to confirm a value landed after a `config set` exited non-zero.
+*/
+function deepEqual(a, b) {
+	if (Object.is(a, b)) return true;
+	if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) return false;
+	const aIsArr = Array.isArray(a);
+	const bIsArr = Array.isArray(b);
+	if (aIsArr !== bIsArr) return false;
+	if (aIsArr && bIsArr) {
+		if (a.length !== b.length) return false;
+		return a.every((v, i) => deepEqual(v, b[i]));
+	}
+	const ao = a;
+	const bo = b;
+	const aKeys = Object.keys(ao);
+	const bKeys = Object.keys(bo);
+	if (aKeys.length !== bKeys.length) return false;
+	return aKeys.every((k) => Object.prototype.hasOwnProperty.call(bo, k) && deepEqual(ao[k], bo[k]));
+}
+/**
 * 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
@@ -1793,6 +1823,45 @@ var OpenClawApplier = class {
 		this.configSetQueue = result.catch(() => void 0);
 		return result;
 	}
+	/**
+	* Read back a single config path and compare it to the value we tried to
+	* write. Used by `applyConfig`'s verify-after-write: a `config set` can exit
+	* non-zero (a hot-reload races the write, OpenClaw's clobber protection
+	* fires) even though the value actually landed, exactly like `applyPlugin`'s
+	* install-then-check tolerance.
+	*
+	* OpenClaw REDACTS sensitive values on `config get`, returning the literal
+	* `__OPENCLAW_REDACTED__` instead of the real value. Treat that as a match:
+	* the key exists and OpenClaw is hiding it, so a deep-equal against the
+	* intended value would otherwise be a false negative and force a re-throw.
+	*/
+	async configValueMatches(path, expected) {
+		try {
+			const { stdout } = await execFileAsync$1("openclaw", [
+				"config",
+				"get",
+				path
+			], { timeout: 1e4 });
+			const actual = JSON.parse(stdout.trim());
+			if (actual === OPENCLAW_REDACTED) return true;
+			return deepEqual(actual, expected);
+		} catch {
+			return false;
+		}
+	}
+	/**
+	* Run a read-back `check` with the same retry/backoff cadence as the config
+	* writes — the settling hot-reload may still be rewriting openclaw.json when
+	* we first read back, so a single check can be a false negative. Returns true
+	* on the first success, false once all attempts are exhausted.
+	*/
+	async verifyApplied(check) {
+		for (let attempt = 0; attempt <= this.configSetRetries; attempt++) {
+			if (await check()) return true;
+			if (attempt < this.configSetRetries && this.configSetRetryDelayMs > 0) await delay$1(this.configSetRetryDelayMs * 2 ** attempt);
+		}
+		return false;
+	}
 	async applyPlugin(spec, _installPath, opts) {
 		const pkg = stripPluginVersion(spec);
 		await this.ensurePluginsAllow(pkg);
@@ -2023,6 +2092,13 @@ var OpenClawApplier = class {
 			try {
 				await this.runConfigSet([parentPath, JSON.stringify(merged)]);
 			} catch (err) {
+				if (await this.verifyApplied(async () => {
+					const after = await readParentObject(parentPath);
+					return [...dottedKvs.entries()].every(([k, v]) => deepEqual(after[k], v));
+				})) {
+					log$3.warn({ parentPath }, "openclaw config set exited non-zero but config landed — continuing");
+					continue;
+				}
 				log$3.error({
 					err: err instanceof Error ? err.message : String(err),
 					parentPath
@@ -2033,11 +2109,16 @@ var OpenClawApplier = class {
 		if (leaves.length > 0) try {
 			await this.runConfigSet(["--batch-json", JSON.stringify(leaves)]);
 		} catch (err) {
-			log$3.error({
-				err: err instanceof Error ? err.message : String(err),
-				batch: leaves
-			}, "Failed to set config via openclaw config set --batch-json");
-			throw err;
+			if (await this.verifyApplied(async () => {
+				return (await Promise.all(leaves.map((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({
+					err: err instanceof Error ? err.message : String(err),
+					batch: leaves
+				}, "Failed to set config via openclaw config set --batch-json");
+				throw err;
+			}
 		}
 	}
 	/**

package/package.json

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