@alfe.ai/integrations 0.0.8 → 0.0.9

package/dist/index.d.ts

@@ -604,20 +604,19 @@ interface OpenClawApplierOptions {
   workspace: string;
   /** Override skills directory (defaults to ~/.alfe/skills/) */
   skillsDir?: string;
-  /** Path to the OpenClaw agent config file (defaults to {workspace}/config.json) */
+  /** Path to the integration tracking file (defaults to {workspace}/config.json) */
   configPath?: string;
 }
 declare class OpenClawApplier implements RuntimeApplier {
   readonly runtime = "openclaw";
   private workspace;
   private skillsDir;
-  private configPath;
+  private trackingPath;
   constructor(options: OpenClawApplierOptions);
   applyPlugin(pkg: string): Promise<void>;
   /**
    * Ensure the plugin is in plugins.allow in openclaw.json.
-   * When we skip `openclaw plugins install` (because the plugin dir exists),
-   * the allowlist may not include the plugin — add it if missing.
+   * Uses `openclaw config set` to avoid clobbering OpenClaw's own file format.
    */
   private ensurePluginsAllow;
   /**
@@ -629,29 +628,22 @@ declare class OpenClawApplier implements RuntimeApplier {
   applySkill(name: string, srcPath: string): Promise<void>;
   removeSkill(name: string): Promise<void>;
   /**
-   * Deep-merge integration config into the OpenClaw agent config file.
+   * Apply integration config to the OpenClaw runtime via `openclaw config set`.
    *
-   * Each integration's config contribution is tracked in
-   * `_integrations.{integrationId}` within the config file so it can be
-   * cleanly removed later.
+   * Each integration's config contribution is tracked in the tracking file
+   * (config.json) so it can be cleanly removed later.
    */
   applyConfig(integrationId: string, config: Record<string, unknown>): Promise<void>;
   /**
    * Remove config previously applied by an integration.
    *
-   * Rebuilds the config by re-merging all remaining integrations' configs,
-   * ensuring clean removal without orphaned keys.
+   * Reads the tracking file to find which config keys this integration set,
+   * then removes them via `openclaw config unset`.
    */
   removeConfig(integrationId: string): Promise<void>;
   isAvailable(): Promise<boolean>;
-  private readConfig;
-  private writeConfig;
-  /**
-   * Extract the base config by stripping all keys that were contributed
-   * by integrations. This is done by removing each integration's keys
-   * from the current config.
-   */
-  private getBaseConfig;
+  private readTracking;
+  private writeTracking;
 }
 //#endregion
 //#region src/lock.d.ts

package/dist/index.js

@@ -1178,67 +1178,82 @@ var IntegrationManager = class {
 /**
 * OpenClawApplier — applies plugins, skills, and config to the OpenClaw runtime.
 *
-* Plugins are installed via `npm install` in the OpenClaw workspace directory.
+* Plugins are installed via `openclaw plugins install`.
 * Skills are copied to ~/.alfe/skills/{name}.
-* Config is deep-merged into the OpenClaw agent config, with per-integration
-* tracking so changes can be cleanly removed on deactivation.
+* Config is applied via `openclaw config set` so OpenClaw manages its own
+* config file (openclaw.json) without clobbering. Per-integration tracking
+* is stored in a separate tracking file (config.json) for clean removal.
 */
 const execFileAsync = promisify(execFile);
+const log = createLogger("OpenClawApplier");
 const DEFAULT_SKILLS_DIR = join(homedir(), ".alfe", "skills");
 /**
-* Deep-merge source into target, returning a new object.
-* Arrays are replaced, not concatenated.
+* Flatten a nested config object into dot-path key-value pairs.
+* e.g. { gateway: { bind: "lan" } } → [["gateway.bind", "lan"]]
 */
-function deepMerge(target, source) {
-	const result = { ...target };
-	for (const key of Object.keys(source)) {
-		const srcVal = source[key];
-		const tgtVal = result[key];
-		if (srcVal !== null && typeof srcVal === "object" && !Array.isArray(srcVal) && tgtVal !== null && typeof tgtVal === "object" && !Array.isArray(tgtVal)) result[key] = deepMerge(tgtVal, srcVal);
-		else result[key] = srcVal;
-	}
-	return result;
+function flattenConfig(obj, prefix = "") {
+	const pairs = [];
+	for (const [key, val] of Object.entries(obj)) {
+		const path = prefix ? `${prefix}.${key}` : key;
+		if (val !== null && typeof val === "object" && !Array.isArray(val)) pairs.push(...flattenConfig(val, path));
+		else pairs.push([path, val]);
+	}
+	return pairs;
 }
 var OpenClawApplier = class {
 	runtime = "openclaw";
 	workspace;
 	skillsDir;
-	configPath;
+	trackingPath;
 	constructor(options) {
 		this.workspace = options.workspace;
 		this.skillsDir = options.skillsDir ?? DEFAULT_SKILLS_DIR;
-		this.configPath = options.configPath ?? join(this.workspace, "config.json");
+		this.trackingPath = options.configPath ?? join(this.workspace, "config.json");
 	}
 	async applyPlugin(pkg) {
-		if (this.isPluginInstalled(pkg)) {
-			this.ensurePluginsAllow(pkg);
-			return;
+		if (!this.isPluginInstalled(pkg)) {
+			await execFileAsync("openclaw", [
+				"plugins",
+				"install",
+				pkg
+			], { timeout: 6e4 });
+			await new Promise((r) => {
+				setTimeout(r, 500);
+			});
 		}
-		await execFileAsync("openclaw", [
-			"plugins",
-			"install",
-			pkg
-		], { timeout: 6e4 });
+		await this.ensurePluginsAllow(pkg);
 	}
 	/**
 	* Ensure the plugin is in plugins.allow in openclaw.json.
-	* When we skip `openclaw plugins install` (because the plugin dir exists),
-	* the allowlist may not include the plugin — add it if missing.
+	* Uses `openclaw config set` to avoid clobbering OpenClaw's own file format.
 	*/
-	ensurePluginsAllow(pkg) {
-		const configPath = join(homedir(), ".openclaw", "openclaw.json");
-		if (!existsSync(configPath)) return;
+	async ensurePluginsAllow(pkg) {
+		let currentAllow = [];
 		try {
-			const raw = readFileSync(configPath, "utf-8");
-			const config = JSON.parse(raw);
-			const plugins = config.plugins ?? {};
-			const allow = plugins.allow ?? [];
-			if (!allow.includes(pkg)) {
-				plugins.allow = [...allow, pkg];
-				config.plugins = plugins;
-				writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
-			}
+			const { stdout } = await execFileAsync("openclaw", [
+				"config",
+				"get",
+				"plugins.allow"
+			], { timeout: 1e4 });
+			const parsed = JSON.parse(stdout.trim());
+			if (Array.isArray(parsed)) currentAllow = parsed;
 		} catch {}
+		if (currentAllow.includes(pkg)) return;
+		const updated = [...currentAllow, pkg];
+		try {
+			await execFileAsync("openclaw", [
+				"config",
+				"set",
+				"plugins.allow",
+				JSON.stringify(updated),
+				"--strict-json"
+			], { timeout: 1e4 });
+		} catch (err) {
+			log.warn({
+				err: err instanceof Error ? err.message : String(err),
+				pkg
+			}, "Failed to set plugins.allow via openclaw config set");
+		}
 	}
 	/**
 	* Check if a plugin is already installed in ~/.openclaw/extensions/.
@@ -1273,69 +1288,76 @@ var OpenClawApplier = class {
 		return Promise.resolve();
 	}
 	/**
-	* Deep-merge integration config into the OpenClaw agent config file.
+	* Apply integration config to the OpenClaw runtime via `openclaw config set`.
 	*
-	* Each integration's config contribution is tracked in
-	* `_integrations.{integrationId}` within the config file so it can be
-	* cleanly removed later.
+	* Each integration's config contribution is tracked in the tracking file
+	* (config.json) so it can be cleanly removed later.
 	*/
-	applyConfig(integrationId, config) {
-		const current = this.readConfig();
-		const integrations = current._integrations ?? {};
+	async applyConfig(integrationId, config) {
+		const tracking = this.readTracking();
+		const integrations = tracking._integrations ?? {};
 		integrations[integrationId] = config;
-		current._integrations = integrations;
-		const merged = deepMerge(current, config);
-		merged._integrations = current._integrations;
-		this.writeConfig(merged);
-		return Promise.resolve();
+		tracking._integrations = integrations;
+		this.writeTracking(tracking);
+		const pairs = flattenConfig(config);
+		for (const [path, value] of pairs) try {
+			await execFileAsync("openclaw", [
+				"config",
+				"set",
+				path,
+				JSON.stringify(value),
+				"--strict-json"
+			], { timeout: 1e4 });
+		} catch (err) {
+			log.error({
+				err: err instanceof Error ? err.message : String(err),
+				path,
+				value
+			}, "Failed to set config via openclaw config set");
+			throw err;
+		}
 	}
 	/**
 	* Remove config previously applied by an integration.
 	*
-	* Rebuilds the config by re-merging all remaining integrations' configs,
-	* ensuring clean removal without orphaned keys.
+	* Reads the tracking file to find which config keys this integration set,
+	* then removes them via `openclaw config unset`.
 	*/
-	removeConfig(integrationId) {
-		const current = this.readConfig();
-		const integrations = current._integrations ?? {};
-		if (!(integrationId in integrations)) return Promise.resolve();
-		const remainingIntegrations = Object.fromEntries(Object.entries(integrations).filter(([key]) => key !== integrationId));
-		let rebuilt = this.getBaseConfig(current);
-		for (const cfg of Object.values(remainingIntegrations)) rebuilt = deepMerge(rebuilt, cfg);
-		rebuilt._integrations = remainingIntegrations;
-		this.writeConfig(rebuilt);
-		return Promise.resolve();
+	async removeConfig(integrationId) {
+		const tracking = this.readTracking();
+		const integrations = tracking._integrations ?? {};
+		if (!(integrationId in integrations)) return;
+		const integrationConfig = integrations[integrationId];
+		const pairs = flattenConfig(integrationConfig);
+		for (const [path] of pairs) try {
+			await execFileAsync("openclaw", [
+				"config",
+				"unset",
+				path
+			], { timeout: 1e4 });
+		} catch (err) {
+			log.warn({
+				err: err instanceof Error ? err.message : String(err),
+				path
+			}, "Failed to unset config via openclaw config unset");
+		}
+		tracking._integrations = Object.fromEntries(Object.entries(integrations).filter(([key]) => key !== integrationId));
+		this.writeTracking(tracking);
 	}
 	isAvailable() {
 		return Promise.resolve(existsSync(this.workspace));
 	}
-	readConfig() {
-		if (!existsSync(this.configPath)) return {};
+	readTracking() {
+		if (!existsSync(this.trackingPath)) return {};
 		try {
-			return JSON.parse(readFileSync(this.configPath, "utf-8"));
+			return JSON.parse(readFileSync(this.trackingPath, "utf-8"));
 		} catch {
 			return {};
 		}
 	}
-	writeConfig(config) {
-		mkdirSync(join(this.configPath, ".."), { recursive: true });
-		writeFileSync(this.configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
-	}
-	/**
-	* Extract the base config by stripping all keys that were contributed
-	* by integrations. This is done by removing each integration's keys
-	* from the current config.
-	*/
-	getBaseConfig(current) {
-		const integrations = current._integrations ?? {};
-		const allIntegrationKeys = /* @__PURE__ */ new Set();
-		for (const cfg of Object.values(integrations)) for (const key of Object.keys(cfg)) allIntegrationKeys.add(key);
-		const base = {};
-		for (const [key, val] of Object.entries(current)) {
-			if (key === "_integrations") continue;
-			if (!allIntegrationKeys.has(key)) base[key] = val;
-		}
-		return base;
+	writeTracking(config) {
+		mkdirSync(join(this.trackingPath, ".."), { recursive: true });
+		writeFileSync(this.trackingPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
 	}
 };
 //#endregion

package/package.json

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