@alfe.ai/integrations 0.1.4 → 0.1.6

package/dist/index.d.ts

@@ -8,6 +8,14 @@ import { Manager } from "@alfe.ai/mcp-bundler";
  *
  * Calls GET /integrations/registry (public, no auth required) and caches the result.
  * The API URL can be passed explicitly or set via ALFE_API_URL env var.
+ *
+ * The cache is time-bounded by a TTL (default 60s). Long-running consumers — chiefly
+ * the agent daemon, which constructs the Registry once at startup and never restarts —
+ * would otherwise be pinned to the registry snapshot taken at process boot, and could
+ * never resolve a version published after the daemon came up (the "stale cache" bug).
+ * With a TTL, every consumer self-heals within a bounded window. The resolve-for-install
+ * path additionally forces a fresh read (see `load({ fresh: true })`) because installing
+ * a specific version is a rare, correctness-critical action that must never race the TTL.
  */
 interface RegistryEntry {
   /** Human-readable display name (e.g. 'Alfe Voice') */
@@ -69,26 +77,51 @@ interface RegistryIndex {
 type RegistryFetcher = () => Promise<(RegistryEntry & {
   id: string;
 })[]>;
+/** Default cache TTL — refetch the registry index after this many ms. */
+declare const DEFAULT_REGISTRY_TTL_MS = 60000;
+interface RegistryOptions {
+  /**
+   * How long (ms) a loaded index is considered fresh before `load()` refetches.
+   * Defaults to {@link DEFAULT_REGISTRY_TTL_MS} (60s). A non-positive value
+   * disables time-based caching (every `load()` refetches).
+   */
+  ttlMs?: number;
+}
+/** Options for a single `load()` call. */
+interface LoadOptions {
+  /** Bypass the cache and refetch the index even if it's still within TTL. */
+  fresh?: boolean;
+}
 declare class Registry {
   private index;
+  private loadedAt;
   private fetcher;
+  private ttlMs;
   /**
    * @param fetcher - Function that fetches the integrations array from the registry API.
    *                  Typically backed by api-client's IntegrationsService.getRegistry().
+   * @param options - Optional cache configuration (TTL).
    */
-  constructor(fetcher: RegistryFetcher);
+  constructor(fetcher: RegistryFetcher, options?: RegistryOptions);
+  /** True when the cached index is absent or older than the TTL. */
+  private isStale;
   /**
-   * Load the registry index. Uses cache if already loaded.
+   * Load the registry index. Returns the cached index while it's still within
+   * TTL; refetches once the cache is stale (or when `{ fresh: true }` is passed).
    */
-  load(): Promise<RegistryIndex>;
+  load(options?: LoadOptions): Promise<RegistryIndex>;
   /**
-   * Force reload the index (bypass cache).
+   * Force reload the index (bypass cache). Equivalent to `load({ fresh: true })`.
    */
   reload(): Promise<RegistryIndex>;
   /**
    * Get a specific integration entry by name.
+   *
+   * @param fresh - When true, force a fresh fetch before reading (used by the
+   *                resolve-for-install path so a stale version list never blocks
+   *                a just-published version).
    */
-  get(id: string): Promise<RegistryEntry | undefined>;
+  get(id: string, fresh?: boolean): Promise<RegistryEntry | undefined>;
   /**
    * List all integrations in the registry.
    */
@@ -115,6 +148,20 @@ interface ResolvedIntegration {
   subdir?: string;
   description: string;
 }
+/** Options for a single `resolve()` call. */
+interface ResolveOptions {
+  /**
+   * Bypass the registry cache and read a fresh index before resolving.
+   *
+   * The install/reconcile path sets this: installing a specific version is a
+   * rare, user-triggered, correctness-critical action that must never resolve
+   * against a stale cached version list (the cause of the
+   * `Version "x" not found … Available versions: …` install failure on a
+   * long-running daemon). High-frequency read-only uses (marketplace
+   * listing/search) leave it unset and keep the TTL cache.
+   */
+  fresh?: boolean;
+}
 declare class RegistryResolveError extends Error {
   constructor(message: string);
 }
@@ -126,9 +173,11 @@ declare class Resolver {
    *
    * @param name - Integration name (e.g. "discord")
    * @param version - Specific version (e.g. "1.0.0") or undefined for latest
+   * @param options - Pass `{ fresh: true }` to bypass the registry cache
+   *                  (used by the install/reconcile path).
    * @returns Resolved integration with repo URL and commit hash
    */
-  resolve(id: string, version?: string): Promise<ResolvedIntegration>;
+  resolve(id: string, version?: string, options?: ResolveOptions): Promise<ResolvedIntegration>;
   /**
    * Check if an integration exists in the registry.
    */
@@ -238,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 */
@@ -699,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";
@@ -706,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.
    *
@@ -875,4 +964,4 @@ declare class IntegrationManagerAdapter implements IIntegrationManager {
   resetReinstallAttempts(integrationId: string): void;
 }
 //#endregion
-export { type CredentialsResolver, type HookEnvOptions, type HookResult, type IIntegrationManager, type InstalledInfo, Installer, InstallerError, type IntegrationConfigureParams, type IntegrationHealthParams, type IntegrationInfo, type IntegrationInstallParams, IntegrationManager, IntegrationManagerAdapter, type IntegrationManagerOptions, type IntegrationRemoveParams, LockManager, McpApplier, type McpApplierOptions, OpenClawApplier, type OpenClawApplierOptions, type PlatformContext, Registry, type RegistryEntry, type RegistryFetcher, type RegistryIndex, RegistryResolveError, type ResolvedIntegration, Resolver, type RuntimeApplier, type RuntimeDesiredState, type RuntimeLockFile, type RuntimePluginEntry, type RuntimeSkillEntry, StateManager, buildHookEnv, resolveInstallsForRuntime, runHook, runHookWithContext };
+export { type CredentialsResolver, DEFAULT_REGISTRY_TTL_MS, type HookEnvOptions, type HookResult, type IIntegrationManager, type InstalledInfo, Installer, InstallerError, type IntegrationConfigureParams, type IntegrationHealthParams, type IntegrationInfo, type IntegrationInstallParams, IntegrationManager, IntegrationManagerAdapter, type IntegrationManagerOptions, type IntegrationRemoveParams, type LoadOptions, LockManager, McpApplier, type McpApplierOptions, OpenClawApplier, type OpenClawApplierOptions, type PlatformContext, Registry, type RegistryEntry, type RegistryFetcher, type RegistryIndex, type RegistryOptions, RegistryResolveError, type ResolveOptions, type ResolvedIntegration, Resolver, type RuntimeApplier, type RuntimeDesiredState, type RuntimeLockFile, type RuntimePluginEntry, type RuntimeSkillEntry, StateManager, buildHookEnv, resolveInstallsForRuntime, runHook, runHookWithContext };

package/dist/index.js

@@ -6,21 +6,34 @@ import { closeSync, copyFileSync, cpSync, existsSync, mkdirSync, mkdtempSync, op
 import { buildConfigValidationSchema, parseManifestFile } from "@alfe.ai/integration-manifest";
 import { createLogger } from "@auriclabs/logger";
 //#region src/registry.ts
+/** Default cache TTL — refetch the registry index after this many ms. */
+const DEFAULT_REGISTRY_TTL_MS = 6e4;
 var Registry = class {
 	index = null;
+	loadedAt = 0;
 	fetcher;
+	ttlMs;
 	/**
 	* @param fetcher - Function that fetches the integrations array from the registry API.
 	*                  Typically backed by api-client's IntegrationsService.getRegistry().
+	* @param options - Optional cache configuration (TTL).
 	*/
-	constructor(fetcher) {
+	constructor(fetcher, options = {}) {
 		this.fetcher = fetcher;
+		this.ttlMs = options.ttlMs ?? 6e4;
+	}
+	/** True when the cached index is absent or older than the TTL. */
+	isStale() {
+		if (!this.index) return true;
+		if (this.ttlMs <= 0) return true;
+		return Date.now() - this.loadedAt >= this.ttlMs;
 	}
 	/**
-	* Load the registry index. Uses cache if already loaded.
+	* Load the registry index. Returns the cached index while it's still within
+	* TTL; refetches once the cache is stale (or when `{ fresh: true }` is passed).
 	*/
-	async load() {
-		if (this.index) return this.index;
+	async load(options = {}) {
+		if (!options.fresh && this.index && !this.isStale()) return this.index;
 		const raw = await this.fetcher();
 		const integrations = {};
 		for (const entry of raw) {
@@ -31,20 +44,25 @@ var Registry = class {
 			version: 1,
 			integrations
 		};
+		this.loadedAt = Date.now();
 		return this.index;
 	}
 	/**
-	* Force reload the index (bypass cache).
+	* Force reload the index (bypass cache). Equivalent to `load({ fresh: true })`.
 	*/
 	async reload() {
 		this.index = null;
-		return this.load();
+		return this.load({ fresh: true });
 	}
 	/**
 	* Get a specific integration entry by name.
+	*
+	* @param fresh - When true, force a fresh fetch before reading (used by the
+	*                resolve-for-install path so a stale version list never blocks
+	*                a just-published version).
 	*/
-	async get(id) {
-		return (await this.load()).integrations[id];
+	async get(id, fresh = false) {
+		return (await this.load({ fresh })).integrations[id];
 	}
 	/**
 	* List all integrations in the registry.
@@ -83,10 +101,12 @@ var Resolver = class {
 	*
 	* @param name - Integration name (e.g. "discord")
 	* @param version - Specific version (e.g. "1.0.0") or undefined for latest
+	* @param options - Pass `{ fresh: true }` to bypass the registry cache
+	*                  (used by the install/reconcile path).
 	* @returns Resolved integration with repo URL and commit hash
 	*/
-	async resolve(id, version) {
-		const entry = await this.registry.get(id);
+	async resolve(id, version, options = {}) {
+		const entry = await this.registry.get(id, options.fresh);
 		if (!entry) throw new RegistryResolveError(`Integration "${id}" not found in registry`);
 		const resolvedVersion = version && version.length > 0 ? version : entry.latest;
 		if (!entry.versions.includes(resolvedVersion)) throw new RegistryResolveError(`Version "${resolvedVersion}" not found for integration "${id}". Available versions: ${entry.versions.join(", ")}`);
@@ -966,7 +986,7 @@ var IntegrationManager = class {
 				resolved = buildCustomResolved(name, customSource);
 				this.log.info(`Custom Connection install: ${name} from ${resolved.repository}@${resolved.commit}`);
 			} else {
-				resolved = await this.resolver.resolve(name, version);
+				resolved = await this.resolver.resolve(name, version, { fresh: true });
 				this.log.info(`Resolved ${name}@${resolved.version} from ${resolved.repository}`);
 			}
 			const installPath = await this.installer.install(resolved);
@@ -1093,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);
@@ -1116,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}`);
@@ -1593,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)) {
@@ -1657,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");
@@ -1664,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);
@@ -1720,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", [
@@ -1734,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}`.
@@ -1882,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),
@@ -1897,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),
@@ -1924,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),
@@ -1940,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),
@@ -2157,4 +2246,4 @@ var IntegrationManagerAdapter = class {
 	}
 };
 //#endregion
-export { Installer, InstallerError, IntegrationManager, IntegrationManagerAdapter, LockManager, McpApplier, OpenClawApplier, Registry, RegistryResolveError, Resolver, StateManager, buildHookEnv, resolveInstallsForRuntime, runHook, runHookWithContext };
+export { DEFAULT_REGISTRY_TTL_MS, Installer, InstallerError, IntegrationManager, IntegrationManagerAdapter, LockManager, McpApplier, OpenClawApplier, Registry, RegistryResolveError, Resolver, StateManager, buildHookEnv, resolveInstallsForRuntime, runHook, runHookWithContext };

package/package.json

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