@alfe.ai/integrations 0.0.4 → 0.0.6

package/dist/index.d.ts

@@ -146,8 +146,6 @@ declare class InstallerError extends Error {
 }
 declare class Installer {
   private basePath;
-  /** Tracks subdir overrides per integration id */
-  private subdirs;
   /**
    * @param basePath - Override the integrations directory (for testing).
    *                   Defaults to ~/.alfe/integrations/
@@ -155,20 +153,27 @@ declare class Installer {
   constructor(basePath?: string);
   /**
    * Get the path where an integration's content lives.
-   * When a subdir is set, returns the subdir within the clone.
    */
   getInstallPath(name: string): string;
-  /**
-   * Get the root clone path (without subdir).
-   */
-  getClonePath(name: string): string;
   /**
    * Install an integration by cloning its git repo and checking out the pinned commit.
-   * Returns the effective install path (with subdir if present).
+   * For monorepo integrations (with subdir), extracts only the subdir contents.
+   *
+   * If the install path already exists (e.g. from a failed previous install),
+   * it is cleaned up before retrying.
    */
   install(resolved: ResolvedIntegration): Promise<string>;
+  /**
+   * Clone repo directly to the install path (no subdir).
+   */
+  private cloneDirect;
+  /**
+   * Clone monorepo to a temp dir, extract the subdir to the install path, discard the clone.
+   */
+  private cloneAndExtractSubdir;
   /**
    * Update an installed integration to a new version.
+   * Removes old install and does a fresh clone.
    */
   update(name: string, resolved: ResolvedIntegration): Promise<string>;
   /**

package/dist/index.js

@@ -1,8 +1,8 @@
 import { execFile, spawn } from "node:child_process";
 import { promisify } from "node:util";
 import { dirname, join } from "node:path";
-import { homedir } from "node:os";
-import { cpSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import { cpSync, existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
 import { buildConfigValidationSchema, parseManifestFile } from "@alfe.ai/integration-manifest";
 import { createLogger } from "@auriclabs/logger";
 //#region src/registry.ts
@@ -122,6 +122,8 @@ var Resolver = class {
 *
 * Manages the local installation directory for integration repos.
 * Each integration is cloned and checked out to a pinned commit hash.
+* For monorepo integrations (with subdir), only the subdir contents
+* are extracted — the full clone is discarded.
 */
 const execFileAsync$1 = promisify(execFile);
 const INTEGRATIONS_DIR = join(homedir(), ".alfe", "integrations");
@@ -134,8 +136,6 @@ var InstallerError = class extends Error {
 };
 var Installer = class {
 	basePath;
-	/** Tracks subdir overrides per integration id */
-	subdirs = /* @__PURE__ */ new Map();
 	/**
 	* @param basePath - Override the integrations directory (for testing).
 	*                   Defaults to ~/.alfe/integrations/
@@ -145,83 +145,109 @@ var Installer = class {
 	}
 	/**
 	* Get the path where an integration's content lives.
-	* When a subdir is set, returns the subdir within the clone.
 	*/
 	getInstallPath(name) {
-		const base = join(this.basePath, name);
-		const subdir = this.subdirs.get(name);
-		return subdir ? join(base, subdir) : base;
-	}
-	/**
-	* Get the root clone path (without subdir).
-	*/
-	getClonePath(name) {
 		return join(this.basePath, name);
 	}
 	/**
 	* Install an integration by cloning its git repo and checking out the pinned commit.
-	* Returns the effective install path (with subdir if present).
+	* For monorepo integrations (with subdir), extracts only the subdir contents.
+	*
+	* If the install path already exists (e.g. from a failed previous install),
+	* it is cleaned up before retrying.
 	*/
 	async install(resolved) {
-		const clonePath = this.getClonePath(resolved.id);
-		if (existsSync(clonePath)) throw new InstallerError(`Integration "${resolved.id}" is already installed at ${clonePath}`);
-		if (resolved.subdir) this.subdirs.set(resolved.id, resolved.subdir);
+		const installPath = this.getInstallPath(resolved.id);
+		if (existsSync(installPath)) rmSync(installPath, {
+			recursive: true,
+			force: true
+		});
 		mkdirSync(this.basePath, { recursive: true });
+		if (resolved.subdir) await this.cloneAndExtractSubdir(resolved, installPath);
+		else await this.cloneDirect(resolved, installPath);
+		return installPath;
+	}
+	/**
+	* Clone repo directly to the install path (no subdir).
+	*/
+	async cloneDirect(resolved, installPath) {
 		try {
 			await execFileAsync$1("git", [
 				"clone",
 				resolved.repository,
-				clonePath
+				installPath
 			], { timeout: GIT_TIMEOUT_MS });
 			await execFileAsync$1("git", ["checkout", resolved.commit], {
-				cwd: clonePath,
+				cwd: installPath,
 				timeout: GIT_TIMEOUT_MS
 			});
 		} catch (err) {
-			if (existsSync(clonePath)) rmSync(clonePath, {
+			if (existsSync(installPath)) rmSync(installPath, {
 				recursive: true,
 				force: true
 			});
-			this.subdirs.delete(resolved.id);
 			const message = err instanceof Error ? err.message : String(err);
 			throw new InstallerError(`Failed to clone integration "${resolved.id}": ${message}`);
 		}
-		return this.getInstallPath(resolved.id);
 	}
 	/**
-	* Update an installed integration to a new version.
+	* Clone monorepo to a temp dir, extract the subdir to the install path, discard the clone.
 	*/
-	async update(name, resolved) {
-		const clonePath = this.getClonePath(name);
-		if (!existsSync(clonePath)) throw new InstallerError(`Integration "${name}" is not installed — cannot update`);
-		if (resolved.subdir) this.subdirs.set(name, resolved.subdir);
-		else this.subdirs.delete(name);
+	async cloneAndExtractSubdir(resolved, installPath) {
+		if (!resolved.subdir) throw new InstallerError("subdir is required for monorepo extraction");
+		const subdir = resolved.subdir;
+		const tempDir = mkdtempSync(join(tmpdir(), `alfe-clone-${resolved.id}-`));
 		try {
-			await execFileAsync$1("git", ["fetch", "origin"], {
-				cwd: clonePath,
-				timeout: GIT_TIMEOUT_MS
-			});
+			await execFileAsync$1("git", [
+				"clone",
+				resolved.repository,
+				tempDir
+			], { timeout: GIT_TIMEOUT_MS });
 			await execFileAsync$1("git", ["checkout", resolved.commit], {
-				cwd: clonePath,
+				cwd: tempDir,
 				timeout: GIT_TIMEOUT_MS
 			});
+			const subdirPath = join(tempDir, subdir);
+			if (!existsSync(subdirPath)) throw new InstallerError(`Subdir "${subdir}" not found in repo after checkout`);
+			cpSync(subdirPath, installPath, { recursive: true });
 		} catch (err) {
+			if (existsSync(installPath)) rmSync(installPath, {
+				recursive: true,
+				force: true
+			});
+			if (err instanceof InstallerError) throw err;
 			const message = err instanceof Error ? err.message : String(err);
-			throw new InstallerError(`Failed to update integration "${name}" to ${resolved.version}: ${message}`);
+			throw new InstallerError(`Failed to clone integration "${resolved.id}": ${message}`);
+		} finally {
+			rmSync(tempDir, {
+				recursive: true,
+				force: true
+			});
 		}
-		return this.getInstallPath(name);
+	}
+	/**
+	* Update an installed integration to a new version.
+	* Removes old install and does a fresh clone.
+	*/
+	async update(name, resolved) {
+		const installPath = this.getInstallPath(name);
+		if (!existsSync(installPath)) throw new InstallerError(`Integration "${name}" is not installed — cannot update`);
+		rmSync(installPath, {
+			recursive: true,
+			force: true
+		});
+		return this.install(resolved);
 	}
 	/**
 	* Remove an installed integration.
 	*/
 	remove(name) {
-		const clonePath = this.getClonePath(name);
-		if (!existsSync(clonePath)) throw new InstallerError(`Integration "${name}" is not installed at ${clonePath}`);
-		rmSync(clonePath, {
+		const installPath = this.getInstallPath(name);
+		if (!existsSync(installPath)) throw new InstallerError(`Integration "${name}" is not installed at ${installPath}`);
+		rmSync(installPath, {
 			recursive: true,
 			force: true
 		});
-		this.subdirs.delete(name);
 		return Promise.resolve();
 	}
 	/**
@@ -258,7 +284,7 @@ var Installer = class {
 	* Check if an integration is installed.
 	*/
 	isInstalled(name) {
-		return existsSync(this.getClonePath(name));
+		return existsSync(this.getInstallPath(name));
 	}
 };
 //#endregion
@@ -1135,7 +1161,7 @@ var IntegrationManager = class {
 /**
 * OpenClawApplier — applies plugins, skills, and config to the OpenClaw runtime.
 *
-* Plugins are installed via `pnpm add` in the OpenClaw workspace directory.
+* Plugins are installed via `npm install` in the OpenClaw workspace directory.
 * 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.
@@ -1167,16 +1193,18 @@ var OpenClawApplier = class {
 		this.configPath = options.configPath ?? join(this.workspace, "config.json");
 	}
 	async applyPlugin(pkg) {
-		await execFileAsync("pnpm", ["add", pkg], {
-			cwd: this.workspace,
-			timeout: 6e4
-		});
+		await execFileAsync("openclaw", [
+			"plugins",
+			"install",
+			pkg
+		], { timeout: 6e4 });
 	}
 	async removePlugin(pkg) {
-		await execFileAsync("pnpm", ["remove", pkg], {
-			cwd: this.workspace,
-			timeout: 3e4
-		});
+		await execFileAsync("openclaw", [
+			"plugins",
+			"uninstall",
+			pkg
+		], { timeout: 3e4 });
 	}
 	applySkill(name, srcPath) {
 		if (!existsSync(srcPath)) throw new Error(`Skill source path not found: ${srcPath}`);

package/package.json

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