@alfe.ai/integrations 0.3.2 → 0.4.1

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>;
 }
@@ -1207,6 +1223,29 @@ declare class OpenClawApplier implements RuntimeApplier {
    * the lock is NOT re-entrant, so this stays an `*Unlocked` internal.
    */
   private dropSubtreeKeysUnlocked;
+  /**
+   * `openclaw config unset <leafPath>`, UNLOCKED, with a fallback for custom
+   * model providers. Unsetting a single leaf under a custom provider (e.g.
+   * `models.providers.zhipu.baseUrl`) is REJECTED by schema validation — a
+   * custom provider without baseUrl is an invalid partial — so the leaf is
+   * never removed and stale/broken config leaks on every removal cycle. On that
+   * specific validation failure, fall back to unsetting the IMMEDIATE parent
+   * subtree (`models.providers.zhipu`), which validates cleanly and removes the
+   * provider whole. The rejection is itself the signal that our key is
+   * STRUCTURAL to the provider (the object can't validly survive without it), so
+   * removing the provider node is the correct terminal state — and we only ever
+   * escalate to the immediate parent, never a wider path.
+   *
+   * `unsetParents` dedupes across the sibling leaves of one removal pass: once
+   * the provider subtree is unset for `models.providers.zhipu.baseUrl`, the
+   * follow-up `.apiKey` / `.models` leaves skip re-issuing the parent unset.
+   *
+   * Warn-tolerant (a failed unset of an already-gone key must never fail the
+   * caller) and assumes the shared CLI lock is held — stays an `*Unlocked`
+   * internal since the lock is NOT re-entrant. Shared by `removeConfig`
+   * (whole-integration teardown) and `applyConfig`'s stale-leaf diff.
+   */
+  private unsetLeafPathUnlocked;
   /**
    * Raw single-key config write — `openclaw config set <key> <value>`.
    *
@@ -1218,6 +1257,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 +1333,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

@@ -2166,6 +2166,22 @@ function isMalformedStateDbError(err) {
 	const e = err;
 	return `${e.message}\n${e.stderr ?? ""}\n${e.stdout ?? ""}`.toLowerCase().includes(MALFORMED_STATE_DB_PHRASE);
 }
+/**
+* OpenClaw rejects `config unset` of a single leaf under a CUSTOM model provider
+* when the removal would leave a schema-invalid partial — e.g. unsetting
+* `models.providers.zhipu.baseUrl` fails with "custom model providers must
+* declare baseUrl; provider overlays without baseUrl are only supported for
+* bundled providers." Unsetting the WHOLE provider subtree
+* (`models.providers.zhipu`) validates cleanly. Detect this failure so the
+* removal path can fall back to unsetting the parent subtree instead of leaving
+* stale/broken config behind. The phrase is stable and specific enough to match
+* directly (case-insensitive); it covers baseUrl and any other required
+* structural field ("...must declare <field>").
+*/
+const INVALID_PARTIAL_PROVIDER_PHRASE = "custom model providers must declare";
+function isInvalidPartialProviderUnset(err) {
+	return (err instanceof Error ? err.message : String(err)).toLowerCase().includes(INVALID_PARTIAL_PROVIDER_PHRASE);
+}
 const delay$1 = (ms) => new Promise((resolve) => {
 	setTimeout(resolve, ms);
 });
@@ -2650,23 +2666,39 @@ var OpenClawApplier = class {
 	async ensurePluginsAllowUnlocked(pkgs) {
 		const wanted = Array.isArray(pkgs) ? pkgs : [pkgs];
 		let currentAllow = [];
+		let readTrustworthy = true;
 		try {
 			const { stdout } = await execFileAsync$1("openclaw", [
 				"config",
 				"get",
 				"plugins.allow"
 			], { timeout: 1e4 });
-			const parsed = JSON.parse(stdout.trim());
-			if (Array.isArray(parsed)) currentAllow = parsed;
-		} catch {}
+			const trimmed = stdout.trim();
+			if (trimmed === "") {} else try {
+				const parsed = JSON.parse(trimmed);
+				if (Array.isArray(parsed)) currentAllow = parsed;
+				else if (parsed === null) {} else readTrustworthy = false;
+			} catch {
+				readTrustworthy = false;
+			}
+		} catch {
+			readTrustworthy = false;
+		}
 		const missing = [...new Set([...wanted, ...BUNDLED_BASELINE_ALLOW])].filter((id) => !currentAllow.includes(id));
 		if (missing.length === 0) return;
+		if (!readTrustworthy) {
+			log$3.warn({
+				pkgs: wanted,
+				missing
+			}, "plugins.allow read was not trustworthy (non-empty parse failure or command error) — skipping the allow-list write to avoid replacing a value not proven to be a superset");
+			return;
+		}
 		const updated = [...currentAllow, ...missing];
 		try {
 			await this.runConfigSetUnlocked([
 				"plugins.allow",
 				JSON.stringify(updated),
-				"--merge"
+				"--replace"
 			]);
 		} catch (err) {
 			log$3.warn({
@@ -2851,14 +2883,8 @@ var OpenClawApplier = class {
 			const prev = partitionEntries(flattenConfig(previous));
 			const nextLeafPaths = new Set(leaves.map((l) => l.path));
 			const staleLeaves = prev.leaves.filter((l) => !nextLeafPaths.has(l.path));
-			for (const { path } of staleLeaves) try {
-				await this.runConfigCommandUnlocked(["unset", path]);
-			} catch (err) {
-				log$3.warn({
-					err: err instanceof Error ? err.message : String(err),
-					path
-				}, "Failed to unset stale config leaf during applyConfig diff");
-			}
+			const unsetParents = /* @__PURE__ */ new Set();
+			for (const { path } of staleLeaves) await this.unsetLeafPathUnlocked(path, unsetParents);
 			for (const [parentPath, prevKvs] of prev.subtreesByParent) {
 				const nextKvs = subtreesByParent.get(parentPath);
 				const goneKeys = [...prevKvs.keys()].filter((k) => !nextKvs?.has(k));
@@ -2926,14 +2952,8 @@ var OpenClawApplier = class {
 		if (!(integrationId in integrations)) return;
 		const integrationConfig = integrations[integrationId];
 		const { leaves, subtreesByParent } = partitionEntries(flattenConfig(integrationConfig));
-		for (const { path } of leaves) try {
-			await this.runConfigCommandUnlocked(["unset", path]);
-		} catch (err) {
-			log$3.warn({
-				err: err instanceof Error ? err.message : String(err),
-				path
-			}, "Failed to unset config via openclaw config unset");
-		}
+		const unsetParents = /* @__PURE__ */ new Set();
+		for (const { path } of leaves) await this.unsetLeafPathUnlocked(path, unsetParents);
 		for (const [parentPath, dottedKvs] of subtreesByParent) await this.dropSubtreeKeysUnlocked(parentPath, new Set(dottedKvs.keys()));
 		tracking._integrations = Object.fromEntries(Object.entries(integrations).filter(([key]) => key !== integrationId));
 		this.writeTracking(tracking);
@@ -2968,6 +2988,56 @@ var OpenClawApplier = class {
 		}
 	}
 	/**
+	* `openclaw config unset <leafPath>`, UNLOCKED, with a fallback for custom
+	* model providers. Unsetting a single leaf under a custom provider (e.g.
+	* `models.providers.zhipu.baseUrl`) is REJECTED by schema validation — a
+	* custom provider without baseUrl is an invalid partial — so the leaf is
+	* never removed and stale/broken config leaks on every removal cycle. On that
+	* specific validation failure, fall back to unsetting the IMMEDIATE parent
+	* subtree (`models.providers.zhipu`), which validates cleanly and removes the
+	* provider whole. The rejection is itself the signal that our key is
+	* STRUCTURAL to the provider (the object can't validly survive without it), so
+	* removing the provider node is the correct terminal state — and we only ever
+	* escalate to the immediate parent, never a wider path.
+	*
+	* `unsetParents` dedupes across the sibling leaves of one removal pass: once
+	* the provider subtree is unset for `models.providers.zhipu.baseUrl`, the
+	* follow-up `.apiKey` / `.models` leaves skip re-issuing the parent unset.
+	*
+	* Warn-tolerant (a failed unset of an already-gone key must never fail the
+	* caller) and assumes the shared CLI lock is held — stays an `*Unlocked`
+	* internal since the lock is NOT re-entrant. Shared by `removeConfig`
+	* (whole-integration teardown) and `applyConfig`'s stale-leaf diff.
+	*/
+	async unsetLeafPathUnlocked(path, unsetParents) {
+		try {
+			await this.runConfigCommandUnlocked(["unset", path]);
+		} catch (err) {
+			const parentPath = path.includes(".") ? path.slice(0, path.lastIndexOf(".")) : void 0;
+			if (parentPath && isInvalidPartialProviderUnset(err)) {
+				if (unsetParents.has(parentPath)) return;
+				unsetParents.add(parentPath);
+				try {
+					await this.runConfigCommandUnlocked(["unset", parentPath]);
+					log$3.warn({
+						path,
+						parentPath
+					}, "Leaf unset rejected as an invalid partial custom provider — unset the parent subtree instead");
+				} catch (parentErr) {
+					log$3.warn({
+						err: parentErr instanceof Error ? parentErr.message : String(parentErr),
+						parentPath
+					}, "Failed to unset parent subtree after an invalid-partial leaf unset");
+				}
+				return;
+			}
+			log$3.warn({
+				err: err instanceof Error ? err.message : String(err),
+				path
+			}, "Failed to unset config via openclaw config unset");
+		}
+	}
+	/**
 	* Raw single-key config write — `openclaw config set <key> <value>`.
 	*
 	* Deliberately bypasses the `_integrations` tracking that `applyConfig`
@@ -2980,6 +3050,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 +3295,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.1",
   "description": "Integration lifecycle management for Alfe — registry, resolution, installation, and state",
   "type": "module",
   "main": "./dist/index.js",