@alfe.ai/integrations 0.0.1 → 0.0.3

package/dist/index.d.ts

@@ -20,19 +20,59 @@ interface RegistryEntry {
   description: string;
   /** Agent runtimes this integration supports. Empty/absent = universal. */
   supported_agents?: string[];
+  /** URL to integration icon */
+  icon?: string;
+  /** Author info */
+  author?: {
+    name: string;
+    url?: string;
+  } | string;
+  /** Pricing details */
+  pricing?: {
+    type: "free" | "paid";
+    price?: number;
+    currency?: string;
+    interval?: "month" | "year";
+  };
+  /** Feature list for marketplace display */
+  features?: string[];
+  /** Preview image URLs */
+  preview_images?: string[];
+  /** Configuration schema fields */
+  config_schema?: {
+    key: string;
+    label: string;
+    type: string;
+    description?: string;
+    required?: boolean;
+    default?: string | number | boolean;
+    options?: string[];
+    select_options?: {
+      value: string;
+      label: string;
+    }[];
+    oauth_provider?: string;
+  }[];
 }
 interface RegistryIndex {
   version: number;
   integrations: Record<string, RegistryEntry>;
 }
+/**
+ * Fetcher function that returns the raw integrations array from the registry API.
+ * Callers wire this up using their api-client instance so Registry stays dependency-free.
+ */
+type RegistryFetcher = () => Promise<(RegistryEntry & {
+  id: string;
+})[]>;
 declare class Registry {
   private index;
-  private apiUrl;
+  private fetcher;
   /**
-   * @param apiUrl - Base URL for the Alfe API (e.g. "https://api.alfe.ai").
-   *                 Falls back to ALFE_API_URL env var, then the production URL.
+   * @param fetcher - Function that fetches the integrations array from the registry API.
+   *                  Typically backed by api-client's IntegrationsService.getRegistry().
    */
-  constructor(apiUrl?: string);
+  constructor(fetcher: RegistryFetcher);
   /**
    * Load the registry index. Uses cache if already loaded.
    */
@@ -331,6 +371,8 @@ interface IntegrationManagerOptions {
   runtimeAppliers?: Map<string, RuntimeApplier>;
   /** Override lock file path (defaults to ~/.alfe/runtime-lock.json) */
   lockPath?: string;
+  /** Fetcher for the integration registry — should be wired to api-client */
+  registryFetcher: RegistryFetcher;
 }
 interface ManagerResponse {
   ok: boolean;
@@ -367,7 +409,7 @@ declare class IntegrationManager {
   private lockManager;
   /** In-memory secret store — NEVER persisted to disk */
   private secrets;
-  constructor(options?: IntegrationManagerOptions);
+  constructor(options: IntegrationManagerOptions);
   /**
    * Install an integration from the registry.
    *
@@ -560,17 +602,6 @@ interface OpenClawApplierOptions {
   /** Path to the OpenClaw agent config file (defaults to {workspace}/config.json) */
   configPath?: string;
 }
-/**
- * Resolve LLM provider runtime config based on mode.
- *
- * - "alfe_credits": keep manifest config as-is (baseUrl points to local proxy,
- *   apiKey is a dummy — the proxy injects the real key)
- * - "byok": remove baseUrl (SDK uses provider default), set apiKey from
- *   decrypted secret
- *
- * Non-LLM integrations pass through unchanged.
- */
-
 declare class OpenClawApplier implements RuntimeApplier {
   readonly runtime = "openclaw";
   private workspace;
@@ -692,4 +723,4 @@ declare class IntegrationManagerAdapter implements IIntegrationManager {
   uninstall(integrationId: string): Promise<void>;
 }
 //#endregion
-export { 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, OpenClawApplier, type OpenClawApplierOptions, Registry, type RegistryEntry, type RegistryIndex, RegistryResolveError, type ResolvedIntegration, Resolver, type RuntimeApplier, type RuntimeDesiredState, type RuntimeLockFile, type RuntimePluginEntry, type RuntimeSkillEntry, StateManager, buildHookEnv, resolveInstallsForRuntime, runHook, runHookWithContext };
+export { 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, OpenClawApplier, type OpenClawApplierOptions, 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 };

package/dist/index.js

@@ -6,37 +6,27 @@ import { cpSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, write
 import { buildConfigValidationSchema, parseManifestFile } from "@alfe.ai/integration-manifest";
 import { createLogger } from "@auriclabs/logger";
 //#region src/registry.ts
-const DEFAULT_API_URL = "https://api.alfe.ai";
-const REGISTRY_PATH = "/integrations/registry";
 var Registry = class {
 	index = null;
-	apiUrl;
+	fetcher;
 	/**
-	* @param apiUrl - Base URL for the Alfe API (e.g. "https://api.alfe.ai").
-	*                 Falls back to ALFE_API_URL env var, then the production URL.
+	* @param fetcher - Function that fetches the integrations array from the registry API.
+	*                  Typically backed by api-client's IntegrationsService.getRegistry().
 	*/
-	constructor(apiUrl) {
-		this.apiUrl = (apiUrl ?? process.env.ALFE_API_URL ?? DEFAULT_API_URL).replace(/\/+$/, "");
+	constructor(fetcher) {
+		this.fetcher = fetcher;
 	}
 	/**
 	* Load the registry index. Uses cache if already loaded.
 	*/
 	async load() {
 		if (this.index) return this.index;
-		const url = `${this.apiUrl}${REGISTRY_PATH}`;
-		const res = await fetch(url);
-		if (!res.ok) throw new Error(`Failed to fetch registry index from ${url}: ${String(res.status)} ${res.statusText}`);
-		const body = await res.json();
-		if (!body.success || !body.data?.integrations) throw new Error(`Invalid registry response from ${url}`);
-		const raw = body.data.integrations;
-		let integrations;
-		if (Array.isArray(raw)) {
-			integrations = {};
-			for (const entry of raw) {
-				const { id, ...rest } = entry;
-				integrations[id] = rest;
-			}
-		} else integrations = raw;
+		const raw = await this.fetcher();
+		const integrations = {};
+		for (const entry of raw) {
+			const { id, ...rest } = entry;
+			integrations[id] = rest;
+		}
 		this.index = {
 			version: 1,
 			integrations
@@ -98,7 +88,7 @@ var Resolver = class {
 	async resolve(id, version) {
 		const entry = await this.registry.get(id);
 		if (!entry) throw new RegistryResolveError(`Integration "${id}" not found in registry`);
-		const resolvedVersion = version ?? entry.latest;
+		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(", ")}`);
 		return {
 			id,
@@ -652,159 +642,6 @@ async function runHookWithContext(integrationPath, hookScript, options) {
 	return runHook(integrationPath, hookScript, buildHookEnv(options));
 }
 //#endregion
-//#region src/appliers/openclaw-applier.ts
-/**
-* OpenClawApplier — applies plugins, skills, and config to the OpenClaw runtime.
-*
-* Plugins are installed via `pnpm add` 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.
-*/
-const execFileAsync = promisify(execFile);
-const DEFAULT_SKILLS_DIR = join(homedir(), ".alfe", "skills");
-/**
-* Deep-merge source into target, returning a new object.
-* Arrays are replaced, not concatenated.
-*/
-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;
-}
-const LLM_INTEGRATION_IDS = new Set(["anthropic", "openai"]);
-/**
-* Resolve LLM provider runtime config based on mode.
-*
-* - "alfe_credits": keep manifest config as-is (baseUrl points to local proxy,
-*   apiKey is a dummy — the proxy injects the real key)
-* - "byok": remove baseUrl (SDK uses provider default), set apiKey from
-*   decrypted secret
-*
-* Non-LLM integrations pass through unchanged.
-*/
-function resolveLlmRuntimeConfig(integrationId, runtimeConfig, integrationConfig, secrets) {
-	if (!LLM_INTEGRATION_IDS.has(integrationId)) return runtimeConfig;
-	if (integrationConfig?.mode === "byok") {
-		const apiKey = secrets?.get("api_key");
-		const config = structuredClone(runtimeConfig);
-		const providers = config.models?.providers;
-		if (providers?.[integrationId]) {
-			delete providers[integrationId].baseUrl;
-			if (apiKey) providers[integrationId].apiKey = apiKey;
-		}
-		return config;
-	}
-	return runtimeConfig;
-}
-var OpenClawApplier = class {
-	runtime = "openclaw";
-	workspace;
-	skillsDir;
-	configPath;
-	constructor(options) {
-		this.workspace = options.workspace;
-		this.skillsDir = options.skillsDir ?? DEFAULT_SKILLS_DIR;
-		this.configPath = options.configPath ?? join(this.workspace, "config.json");
-	}
-	async applyPlugin(pkg) {
-		await execFileAsync("pnpm", ["add", pkg], {
-			cwd: this.workspace,
-			timeout: 6e4
-		});
-	}
-	async removePlugin(pkg) {
-		await execFileAsync("pnpm", ["remove", pkg], {
-			cwd: this.workspace,
-			timeout: 3e4
-		});
-	}
-	applySkill(name, srcPath) {
-		if (!existsSync(srcPath)) throw new Error(`Skill source path not found: ${srcPath}`);
-		mkdirSync(this.skillsDir, { recursive: true });
-		cpSync(srcPath, join(this.skillsDir, name), { recursive: true });
-		return Promise.resolve();
-	}
-	removeSkill(name) {
-		const skillPath = join(this.skillsDir, name);
-		if (existsSync(skillPath)) rmSync(skillPath, {
-			recursive: true,
-			force: true
-		});
-		return Promise.resolve();
-	}
-	/**
-	* Deep-merge integration config into the OpenClaw agent config file.
-	*
-	* Each integration's config contribution is tracked in
-	* `_integrations.{integrationId}` within the config file so it can be
-	* cleanly removed later.
-	*/
-	applyConfig(integrationId, config) {
-		const current = this.readConfig();
-		const integrations = current._integrations ?? {};
-		integrations[integrationId] = config;
-		current._integrations = integrations;
-		const merged = deepMerge(current, config);
-		merged._integrations = current._integrations;
-		this.writeConfig(merged);
-		return Promise.resolve();
-	}
-	/**
-	* Remove config previously applied by an integration.
-	*
-	* Rebuilds the config by re-merging all remaining integrations' configs,
-	* ensuring clean removal without orphaned keys.
-	*/
-	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();
-	}
-	isAvailable() {
-		return Promise.resolve(existsSync(this.workspace));
-	}
-	readConfig() {
-		if (!existsSync(this.configPath)) return {};
-		try {
-			return JSON.parse(readFileSync(this.configPath, "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;
-	}
-};
-//#endregion
 //#region src/integration-manager.ts
 /**
 * Integration Manager — full lifecycle management for Alfe integrations.
@@ -839,12 +676,12 @@ var IntegrationManager = class {
 	/** In-memory secret store — NEVER persisted to disk */
 	secrets = /* @__PURE__ */ new Map();
 	constructor(options) {
-		this.state = new StateManager(options?.statePath);
-		this.registry = new Registry();
+		this.state = new StateManager(options.statePath);
+		this.registry = new Registry(options.registryFetcher);
 		this.resolver = new Resolver(this.registry);
-		this.installer = new Installer(options?.integrationsDir);
-		this.runtimeAppliers = options?.runtimeAppliers ?? /* @__PURE__ */ new Map();
-		this.lockManager = new LockManager(options?.lockPath);
+		this.installer = new Installer(options.integrationsDir);
+		this.runtimeAppliers = options.runtimeAppliers ?? /* @__PURE__ */ new Map();
+		this.lockManager = new LockManager(options.lockPath);
 	}
 	/**
 	* Install an integration from the registry.
@@ -1026,9 +863,8 @@ var IntegrationManager = class {
 					await applier.applySkill(skillName, srcPath);
 				}
 				if (runtimeConfig && Object.keys(runtimeConfig).length > 0) {
-					const resolvedConfig = resolveLlmRuntimeConfig(integrationId, runtimeConfig, entry.config, this.secrets.get(integrationId));
 					this.log.info(`Applying config for ${integrationId} to ${runtimeName}`);
-					await applier.applyConfig(integrationId, resolvedConfig);
+					await applier.applyConfig(integrationId, runtimeConfig);
 				}
 				if (plugins.length > 0 || skills.length > 0) this.lockManager.addEntries(runtimeName, integrationId, manifest.version, plugins, skills, installPath);
 			}
@@ -1313,6 +1149,134 @@ var IntegrationManager = class {
 	}
 };
 //#endregion
+//#region src/appliers/openclaw-applier.ts
+/**
+* OpenClawApplier — applies plugins, skills, and config to the OpenClaw runtime.
+*
+* Plugins are installed via `pnpm add` 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.
+*/
+const execFileAsync = promisify(execFile);
+const DEFAULT_SKILLS_DIR = join(homedir(), ".alfe", "skills");
+/**
+* Deep-merge source into target, returning a new object.
+* Arrays are replaced, not concatenated.
+*/
+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;
+}
+var OpenClawApplier = class {
+	runtime = "openclaw";
+	workspace;
+	skillsDir;
+	configPath;
+	constructor(options) {
+		this.workspace = options.workspace;
+		this.skillsDir = options.skillsDir ?? DEFAULT_SKILLS_DIR;
+		this.configPath = options.configPath ?? join(this.workspace, "config.json");
+	}
+	async applyPlugin(pkg) {
+		await execFileAsync("pnpm", ["add", pkg], {
+			cwd: this.workspace,
+			timeout: 6e4
+		});
+	}
+	async removePlugin(pkg) {
+		await execFileAsync("pnpm", ["remove", pkg], {
+			cwd: this.workspace,
+			timeout: 3e4
+		});
+	}
+	applySkill(name, srcPath) {
+		if (!existsSync(srcPath)) throw new Error(`Skill source path not found: ${srcPath}`);
+		mkdirSync(this.skillsDir, { recursive: true });
+		cpSync(srcPath, join(this.skillsDir, name), { recursive: true });
+		return Promise.resolve();
+	}
+	removeSkill(name) {
+		const skillPath = join(this.skillsDir, name);
+		if (existsSync(skillPath)) rmSync(skillPath, {
+			recursive: true,
+			force: true
+		});
+		return Promise.resolve();
+	}
+	/**
+	* Deep-merge integration config into the OpenClaw agent config file.
+	*
+	* Each integration's config contribution is tracked in
+	* `_integrations.{integrationId}` within the config file so it can be
+	* cleanly removed later.
+	*/
+	applyConfig(integrationId, config) {
+		const current = this.readConfig();
+		const integrations = current._integrations ?? {};
+		integrations[integrationId] = config;
+		current._integrations = integrations;
+		const merged = deepMerge(current, config);
+		merged._integrations = current._integrations;
+		this.writeConfig(merged);
+		return Promise.resolve();
+	}
+	/**
+	* Remove config previously applied by an integration.
+	*
+	* Rebuilds the config by re-merging all remaining integrations' configs,
+	* ensuring clean removal without orphaned keys.
+	*/
+	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();
+	}
+	isAvailable() {
+		return Promise.resolve(existsSync(this.workspace));
+	}
+	readConfig() {
+		if (!existsSync(this.configPath)) return {};
+		try {
+			return JSON.parse(readFileSync(this.configPath, "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;
+	}
+};
+//#endregion
 //#region src/adapter.ts
 var IntegrationManagerAdapter = class {
 	constructor(manager) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alfe.ai/integrations",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "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.1"
+    "@alfe.ai/integration-manifest": "^0.0.2"
   },
   "files": [
     "dist"