@alfe.ai/integrations 0.0.3 → 0.0.5

package/dist/index.d.ts

@@ -8,11 +8,10 @@
 interface RegistryEntry {
   /** Human-readable display name (e.g. 'Alfe Voice') */
   name?: string;
-  repo: string;
-  /** GitHub repository URL (HTTPS, no .git suffix) for public clone */
-  repository?: string;
-  /** Pinned commit SHA — when present, install uses this exact commit instead of a tag */
-  commit?: string;
+  /** GitHub repository URL (HTTPS) for public clone */
+  repository: string;
+  /** Git commit SHA — installer clones and checks out this exact commit */
+  commit: string;
   /** Subdirectory within the repo where the integration lives (for monorepos) */
   subdir?: string;
   versions: string[];
@@ -103,11 +102,10 @@ declare class Registry {
 interface ResolvedIntegration {
   id: string;
   name?: string;
-  repo: string;
+  repository: string;
   version: string;
-  tag: string;
-  /** Pinned commit SHA — when present, installer uses this instead of tag */
-  commit?: string;
+  /** Git commit SHA to checkout after clone */
+  commit: string;
   /** Subdirectory within the repo where the integration lives (for monorepos) */
   subdir?: string;
   description: string;
@@ -123,7 +121,7 @@ declare class Resolver {
    *
    * @param name - Integration name (e.g. "discord")
    * @param version - Specific version (e.g. "1.0.0") or undefined for latest
-   * @returns Resolved integration with repo URL and git tag
+   * @returns Resolved integration with repo URL and commit hash
    */
   resolve(id: string, version?: string): Promise<ResolvedIntegration>;
   /**
@@ -148,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/
@@ -157,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).
+   * Install an integration by cloning its git repo and checking out the pinned commit.
+   * 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.
    */
-  getClonePath(name: string): string;
+  install(resolved: ResolvedIntegration): Promise<string>;
   /**
-   * Install an integration by cloning its git repo and checking out the version tag.
-   * Returns the effective install path (with subdir if present).
+   * Clone repo directly to the install path (no subdir).
    */
-  install(resolved: ResolvedIntegration): Promise<string>;
+  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>;
   /**
@@ -287,6 +290,8 @@ interface IntegrationManifest {
   config_schema: ConfigSchemaField[];
   capabilities: string[];
   hooks: IntegrationHooks;
+  /** Git repository URL (HTTPS, with .git suffix) — used by installer to clone */
+  repository: string;
   /**
    * Agent runtimes this integration supports.
    * If omitted or empty, the integration is considered universal (all runtimes).

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
@@ -83,7 +83,7 @@ var Resolver = class {
 	*
 	* @param name - Integration name (e.g. "discord")
 	* @param version - Specific version (e.g. "1.0.0") or undefined for latest
-	* @returns Resolved integration with repo URL and git tag
+	* @returns Resolved integration with repo URL and commit hash
 	*/
 	async resolve(id, version) {
 		const entry = await this.registry.get(id);
@@ -93,9 +93,8 @@ var Resolver = class {
 		return {
 			id,
 			name: entry.name,
-			repo: entry.repository ? `${entry.repository}.git` : entry.repo,
+			repository: entry.repository,
 			version: resolvedVersion,
-			tag: `v${resolvedVersion}`,
 			commit: entry.commit,
 			subdir: entry.subdir,
 			description: entry.description
@@ -119,10 +118,12 @@ var Resolver = class {
 //#endregion
 //#region src/installer.ts
 /**
-* Installer — git clone/fetch integrations to ~/.alfe/integrations/{name}/.
+* Installer — git clone integrations to ~/.alfe/integrations/{name}/.
 *
 * Manages the local installation directory for integration repos.
-* Each integration is a shallow git clone checked out to a version tag.
+* 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");
@@ -135,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/
@@ -146,100 +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 version tag.
-	* Returns the effective install path (with subdir if present).
+	* Install an integration by cloning its git repo and checking out the pinned commit.
+	* 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 {
-			if (resolved.commit) {
-				await execFileAsync$1("git", [
-					"clone",
-					resolved.repo,
-					clonePath
-				], { timeout: GIT_TIMEOUT_MS });
-				await execFileAsync$1("git", ["checkout", resolved.commit], {
-					cwd: clonePath,
-					timeout: GIT_TIMEOUT_MS
-				});
-			} else await execFileAsync$1("git", [
+			await execFileAsync$1("git", [
 				"clone",
-				"--depth",
-				"1",
-				"--branch",
-				resolved.tag,
-				resolved.repo,
-				clonePath
+				resolved.repository,
+				installPath
 			], { timeout: GIT_TIMEOUT_MS });
+			await execFileAsync$1("git", ["checkout", resolved.commit], {
+				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",
-				"--depth",
-				"1",
-				"origin",
-				`tag`,
-				resolved.tag
-			], {
-				cwd: clonePath,
-				timeout: GIT_TIMEOUT_MS
-			});
-			await execFileAsync$1("git", ["checkout", resolved.tag], {
-				cwd: clonePath,
+				"clone",
+				resolved.repository,
+				tempDir
+			], { timeout: GIT_TIMEOUT_MS });
+			await execFileAsync$1("git", ["checkout", resolved.commit], {
+				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();
 	}
 	/**
@@ -276,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
@@ -711,7 +719,7 @@ var IntegrationManager = class {
 		});
 		try {
 			const resolved = await this.resolver.resolve(name, version);
-			this.log.info(`Resolved ${name}@${resolved.version} from ${resolved.repo}`);
+			this.log.info(`Resolved ${name}@${resolved.version} from ${resolved.repository}`);
 			const installPath = await this.installer.install(resolved);
 			this.log.info(`Cloned to ${installPath}`);
 			const manifestPath = join(installPath, "alfe-integration.yaml");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alfe.ai/integrations",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "description": "Integration lifecycle management for Alfe — registry, resolution, installation, and state",
   "type": "module",
   "main": "./dist/index.js",
@@ -13,7 +13,7 @@
   },
   "dependencies": {
     "@auriclabs/logger": "^0.1.1",
-    "@alfe.ai/integration-manifest": "^0.0.2"
+    "@alfe.ai/integration-manifest": "^0.0.3"
   },
   "files": [
     "dist"