@alfe.ai/integrations 0.3.2 → 0.4.0

package/dist/index.d.ts

@@ -359,6 +359,22 @@ interface RuntimeApplier {
    * its absence and degrade gracefully.
    */
   setConfigRaw?(key: string, value: string): Promise<void>;
+  /**
+   * Optional: read a single raw config key back from the runtime, returning the
+   * scalar value as a string (or `undefined` when the key is unset / can't be
+   * read). Used by the daemon's config-reconcile pass (plan A4) to value-diff
+   * before writing (skip when equal) and to verify a write landed.
+   *
+   * MUST normalize the runtime's `config get` output to the same scalar string
+   * that `setConfigRaw` was called with (e.g. unwrap the JSON quoting OpenClaw's
+   * `config get` adds), so a `getConfigRaw(k) === want` compare is exact.
+   *
+   * Read-back can be a false negative under load (a 2-vCPU box running a
+   * `config get` while the runtime hot-reloads) — callers MUST retry with the
+   * same cadence as a write verify, never one-shot. Appliers that can't read
+   * config omit this method; callers degrade gracefully (blind set, no diff).
+   */
+  getConfigRaw?(key: string): Promise<string | undefined>;
   /** Check if this runtime is available (e.g. workspace directory exists) */
   isAvailable(): Promise<boolean>;
 }
@@ -1218,6 +1234,21 @@ declare class OpenClawApplier implements RuntimeApplier {
    * config writes trigger.
    */
   setConfigRaw(key: string, value: string): Promise<void>;
+  /**
+   * Read a single config key back — `openclaw config get <key>` — and normalize
+   * to the scalar string that `setConfigRaw` would have written. `config get`
+   * emits JSON, so a scalar comes back quoted (`"claude-sonnet-4-6"`); parse it
+   * to the raw value so a `=== want` compare in the daemon's config-reconcile
+   * pass is exact.
+   *
+   * Returns `undefined` when the key is unset, the command fails, or the runtime
+   * REDACTS the value (a sensitive key we can't compare — treat as "unknown" so
+   * the caller doesn't spuriously diff). Under the shared CLI lock so it can't
+   * interleave with a concurrent mutation. NOT self-healing on a malformed state
+   * DB — a read failure returns `undefined`, and the caller's set path (which IS
+   * healing) recovers.
+   */
+  getConfigRaw(key: string): Promise<string | undefined>;
   isAvailable(): Promise<boolean>;
   private readTracking;
   private writeTracking;
@@ -1279,6 +1310,14 @@ declare class HermesApplier implements RuntimeApplier {
    * per-integration removal accounting). Reuses the serialized queue.
    */
   setConfigRaw(key: string, value: string): Promise<void>;
+  /**
+   * Read a single config key back — `hermes config get <key>` — normalized to
+   * the scalar string `setConfigRaw` would have written (used by the daemon's
+   * config-reconcile value-diff + verify, plan A4). Returns `undefined` when the
+   * key is unset or the command fails. Serialized onto the same config queue so
+   * it can't interleave with an in-flight `hermes config set`.
+   */
+  getConfigRaw(key: string): Promise<string | undefined>;
   /**
    * Apply a plugin. The `@alfe.ai/openclaw-*` npm plugins are OpenClaw-specific
    * (they carry the `openclaw` peer dep) and do NOT apply to Hermes — log + skip

package/dist/index.js

@@ -2980,6 +2980,46 @@ var OpenClawApplier = class {
 	setConfigRaw(key, value) {
 		return this.cliLock.run(() => this.runConfigSetUnlocked([key, value]));
 	}
+	/**
+	* Read a single config key back — `openclaw config get <key>` — and normalize
+	* to the scalar string that `setConfigRaw` would have written. `config get`
+	* emits JSON, so a scalar comes back quoted (`"claude-sonnet-4-6"`); parse it
+	* to the raw value so a `=== want` compare in the daemon's config-reconcile
+	* pass is exact.
+	*
+	* Returns `undefined` when the key is unset, the command fails, or the runtime
+	* REDACTS the value (a sensitive key we can't compare — treat as "unknown" so
+	* the caller doesn't spuriously diff). Under the shared CLI lock so it can't
+	* interleave with a concurrent mutation. NOT self-healing on a malformed state
+	* DB — a read failure returns `undefined`, and the caller's set path (which IS
+	* healing) recovers.
+	*/
+	getConfigRaw(key) {
+		return this.cliLock.run(async () => {
+			try {
+				const { stdout } = await execFileAsync$1("openclaw", [
+					"config",
+					"get",
+					key
+				], { timeout: 1e4 });
+				const trimmed = stdout.trim();
+				if (!trimmed) return void 0;
+				let parsed;
+				try {
+					parsed = JSON.parse(trimmed);
+				} catch {
+					return trimmed;
+				}
+				if (parsed === null || parsed === void 0) return void 0;
+				if (parsed === OPENCLAW_REDACTED) return void 0;
+				if (typeof parsed === "string") return parsed;
+				if (typeof parsed === "number" || typeof parsed === "boolean") return String(parsed);
+				return JSON.stringify(parsed);
+			} catch {
+				return;
+			}
+		});
+	}
 	isAvailable() {
 		return Promise.resolve(existsSync(this.home));
 	}
@@ -3185,6 +3225,40 @@ var HermesApplier = class {
 		return this.runConfigSet([key, value]);
 	}
 	/**
+	* Read a single config key back — `hermes config get <key>` — normalized to
+	* the scalar string `setConfigRaw` would have written (used by the daemon's
+	* config-reconcile value-diff + verify, plan A4). Returns `undefined` when the
+	* key is unset or the command fails. Serialized onto the same config queue so
+	* it can't interleave with an in-flight `hermes config set`.
+	*/
+	getConfigRaw(key) {
+		const run = async () => {
+			try {
+				const { stdout } = await execFileAsync("hermes", [
+					"config",
+					"get",
+					key
+				], { timeout: 1e4 });
+				const trimmed = stdout.trim();
+				if (!trimmed) return void 0;
+				try {
+					const parsed = JSON.parse(trimmed);
+					if (parsed === null || parsed === void 0) return void 0;
+					if (typeof parsed === "string") return parsed;
+					if (typeof parsed === "number" || typeof parsed === "boolean") return String(parsed);
+					return JSON.stringify(parsed);
+				} catch {
+					return trimmed;
+				}
+			} catch {
+				return;
+			}
+		};
+		const result = this.configSetQueue.then(run, run);
+		this.configSetQueue = result.catch(() => void 0);
+		return result;
+	}
+	/**
 	* Apply a plugin. The `@alfe.ai/openclaw-*` npm plugins are OpenClaw-specific
 	* (they carry the `openclaw` peer dep) and do NOT apply to Hermes — log + skip
 	* them. The manager catches per-plugin, so a skip here is a correct no-op.

package/package.json

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