@alfe.ai/openclaw-identity 0.0.9 → 0.0.10

package/dist/index.cjs

@@ -1,2 +1,2 @@
-const require_plugin = require("./plugin.cjs");
-module.exports = require_plugin;
+const require_plugin = require("./plugin2.cjs");
+module.exports = require_plugin.plugin;

package/dist/index.js

@@ -1,2 +1,2 @@
-import plugin from "./plugin.js";
+import { t as plugin } from "./plugin2.js";
 export { plugin as default };

package/dist/plugin.cjs

@@ -1,394 +1,2 @@
-let _alfe_ai_config = require("@alfe.ai/config");
-let _alfe_ai_agent_api_client = require("@alfe.ai/agent-api-client");
-let _sinclair_typebox = require("@sinclair/typebox");
-//#region src/plugin.ts
-/**
-* @alfe.ai/openclaw-identity — OpenClaw native plugin
-*
-* HTTP-based identity resolution, permission enforcement, and CRM tools.
-* Installed as part of the core alfe integration on every agent.
-*
-* Hooks:
-*   - message_received  → resolve sender identity via HTTP, cache, gate access
-*   - before_tool_call  → enforce permissions from cached policy
-*   - after_tool_call   → log tool execution audit
-*
-* All data access via AgentApiClient (/agent/identity/* routes).
-* Uses the agent's own API key (from ~/.alfe/config.toml) for authentication.
-*/
-const pkg = (0, require("node:module").createRequire)(require("url").pathToFileURL(__filename).href)("../package.json");
-const CACHE_TTL_MS = 6e4;
-const sessionCache = /* @__PURE__ */ new Map();
-function getCached(key) {
-	const entry = sessionCache.get(key);
-	if (!entry) return null;
-	if (Date.now() > entry.expiresAt) {
-		sessionCache.delete(key);
-		return null;
-	}
-	return entry.value;
-}
-function setCached(key, value) {
-	sessionCache.set(key, {
-		value,
-		expiresAt: Date.now() + CACHE_TTL_MS
-	});
-}
-function ok(data) {
-	return {
-		content: [{
-			type: "text",
-			text: JSON.stringify(data)
-		}],
-		details: data
-	};
-}
-function errResult(message) {
-	return {
-		content: [{
-			type: "text",
-			text: JSON.stringify({ error: message })
-		}],
-		details: { error: message }
-	};
-}
-function defineTool(def) {
-	return {
-		name: def.name,
-		description: def.description,
-		label: def.name,
-		parameters: def.parameters,
-		execute: async (_toolCallId, params) => {
-			try {
-				return ok(await def.handler(params));
-			} catch (e) {
-				return errResult(e.message);
-			}
-		}
-	};
-}
-const plugin = {
-	id: "@alfe.ai/openclaw-identity",
-	name: "Alfe Identity",
-	description: "Identity resolution, access gating, and permission enforcement",
-	version: pkg.version,
-	activate(api) {
-		const log = api.logger;
-		log.info("Alfe Identity plugin activating...");
-		let client;
-		try {
-			const config = (0, _alfe_ai_config.resolveConfig)();
-			client = new _alfe_ai_agent_api_client.AgentApiClient({
-				apiKey: config.apiKey,
-				apiUrl: config.apiUrl
-			});
-		} catch (err) {
-			log.error(`Identity plugin: failed to resolve config — ${err instanceof Error ? err.message : String(err)}`);
-			return;
-		}
-		let failureMode = "open";
-		client.getIntegrationConfig("alfe").then((alfeConfig) => {
-			const mode = alfeConfig.config.identity_failure_mode;
-			if (mode === "open" || mode === "closed" || mode === "permissive") failureMode = mode;
-			log.info(`Identity failure mode: ${failureMode}`);
-		}).catch(() => {
-			log.info(`Identity failure mode: ${failureMode} (default — config fetch failed)`);
-		});
-		const identityToolNames = /* @__PURE__ */ new Set();
-		const tools = [
-			defineTool({
-				name: "who_is_this",
-				description: "Look up full identity context by platform and ID — returns profile, notes, tags, platforms, and recent changelog",
-				parameters: _sinclair_typebox.Type.Object({
-					platform: _sinclair_typebox.Type.String({ description: "Platform name (discord, slack, chat, sms, whatsapp, etc.)" }),
-					platformId: _sinclair_typebox.Type.String({ description: "Platform-specific user identifier" })
-				}),
-				handler: async (params) => {
-					const result = await client.resolveIdentity({
-						platform: params.platform,
-						platformId: params.platformId
-					});
-					if (!result.identityId) return { found: false };
-					return client.getIdentityContext(result.identityId);
-				}
-			}),
-			defineTool({
-				name: "lookup_identity",
-				description: "Search identities by name, email, phone, tag, or platform. Returns multiple matches.",
-				parameters: _sinclair_typebox.Type.Object({
-					query: _sinclair_typebox.Type.Optional(_sinclair_typebox.Type.String({ description: "Text search query" })),
-					status: _sinclair_typebox.Type.Optional(_sinclair_typebox.Type.String()),
-					tag: _sinclair_typebox.Type.Optional(_sinclair_typebox.Type.String()),
-					platform: _sinclair_typebox.Type.Optional(_sinclair_typebox.Type.String())
-				}),
-				handler: (params) => client.searchIdentities({
-					q: params.query,
-					status: params.status,
-					tag: params.tag,
-					platform: params.platform
-				})
-			}),
-			defineTool({
-				name: "create_identity",
-				description: "Create a new identity record with profile fields",
-				parameters: _sinclair_typebox.Type.Object({
-					platform: _sinclair_typebox.Type.String(),
-					platformId: _sinclair_typebox.Type.String(),
-					displayName: _sinclair_typebox.Type.Optional(_sinclair_typebox.Type.String())
-				}),
-				handler: (params) => client.resolveIdentity({
-					platform: params.platform,
-					platformId: params.platformId,
-					displayName: params.displayName
-				})
-			}),
-			defineTool({
-				name: "merge_identities",
-				description: "Merge two identity records — transfers notes, tags, aliases, platforms to survivor",
-				parameters: _sinclair_typebox.Type.Object({
-					survivorId: _sinclair_typebox.Type.String({ description: "Identity to keep" }),
-					mergedId: _sinclair_typebox.Type.String({ description: "Identity to merge into survivor" })
-				}),
-				handler: (params) => client.mergeIdentities(params.survivorId, {
-					mergedId: params.mergedId,
-					changedBy: {
-						type: "agent",
-						id: "plugin"
-					}
-				})
-			}),
-			defineTool({
-				name: "unmerge_identities",
-				description: "Reverse a merge — restore previously merged identity",
-				parameters: _sinclair_typebox.Type.Object({ mergedId: _sinclair_typebox.Type.String({ description: "Identity that was merged (has mergedInto pointer)" }) }),
-				handler: (params) => client.unmergeIdentity(params.mergedId, { changedBy: {
-					type: "agent",
-					id: "plugin"
-				} })
-			}),
-			defineTool({
-				name: "link_platform",
-				description: "Link a platform identity to an existing identity record",
-				parameters: _sinclair_typebox.Type.Object({
-					identityId: _sinclair_typebox.Type.String(),
-					platform: _sinclair_typebox.Type.String(),
-					platformId: _sinclair_typebox.Type.String()
-				}),
-				handler: (params) => client.resolveIdentity({
-					platform: params.platform,
-					platformId: params.platformId
-				})
-			}),
-			defineTool({
-				name: "add_identity_note",
-				description: "Add an observation or note about a contact",
-				parameters: _sinclair_typebox.Type.Object({
-					identityId: _sinclair_typebox.Type.String(),
-					content: _sinclair_typebox.Type.String(),
-					category: _sinclair_typebox.Type.Optional(_sinclair_typebox.Type.String({ description: "observation, preference, relationship, context, or warning" }))
-				}),
-				handler: (params) => client.addIdentityNote(params.identityId, {
-					content: params.content,
-					category: params.category,
-					changedBy: {
-						type: "agent",
-						id: "plugin"
-					}
-				})
-			}),
-			defineTool({
-				name: "tag_identity",
-				description: "Add or remove a tag on an identity",
-				parameters: _sinclair_typebox.Type.Object({
-					identityId: _sinclair_typebox.Type.String(),
-					tag: _sinclair_typebox.Type.String(),
-					action: _sinclair_typebox.Type.String({ description: "'add' or 'remove'" })
-				}),
-				handler: (params) => client.tagIdentity(params.identityId, {
-					tag: params.tag,
-					action: params.action,
-					changedBy: {
-						type: "agent",
-						id: "plugin"
-					}
-				})
-			}),
-			defineTool({
-				name: "get_identity_changelog",
-				description: "Get full changelog for an identity — all versions, diffs, who changed what",
-				parameters: _sinclair_typebox.Type.Object({
-					identityId: _sinclair_typebox.Type.String(),
-					limit: _sinclair_typebox.Type.Optional(_sinclair_typebox.Type.Number())
-				}),
-				handler: (params) => client.getIdentityChangelog(params.identityId, { limit: params.limit })
-			}),
-			defineTool({
-				name: "rollback_identity",
-				description: "Revert an identity to a previous version",
-				parameters: _sinclair_typebox.Type.Object({
-					identityId: _sinclair_typebox.Type.String(),
-					targetVersion: _sinclair_typebox.Type.Number()
-				}),
-				handler: (params) => client.rollbackIdentity(params.identityId, {
-					targetVersion: params.targetVersion,
-					changedBy: {
-						type: "agent",
-						id: "plugin"
-					}
-				})
-			}),
-			defineTool({
-				name: "enforce_policy",
-				description: "Resolve sender identity and return their tool policy",
-				parameters: _sinclair_typebox.Type.Object({
-					platform: _sinclair_typebox.Type.String(),
-					senderId: _sinclair_typebox.Type.String(),
-					channelId: _sinclair_typebox.Type.Optional(_sinclair_typebox.Type.String())
-				}),
-				handler: (params) => client.enforcePolicy({
-					platform: params.platform,
-					senderId: params.senderId,
-					channelId: params.channelId
-				})
-			}),
-			defineTool({
-				name: "check_permission",
-				description: "Check if a specific tool call is allowed for a sender",
-				parameters: _sinclair_typebox.Type.Object({
-					platform: _sinclair_typebox.Type.String(),
-					senderId: _sinclair_typebox.Type.String(),
-					toolName: _sinclair_typebox.Type.String()
-				}),
-				handler: (params) => client.checkToolPermission({
-					platform: params.platform,
-					senderId: params.senderId,
-					toolName: params.toolName
-				})
-			}),
-			defineTool({
-				name: "request_identity_verification",
-				description: "Send a verification phrase to the claimed identity's phone (SMS) or email. The person must relay the phrase back to confirm they own that identity.",
-				parameters: _sinclair_typebox.Type.Object({
-					claimedIdentityId: _sinclair_typebox.Type.String({ description: "Identity being claimed" }),
-					requestingIdentityId: _sinclair_typebox.Type.String({ description: "Identity of the person making the claim" }),
-					requestingPlatform: _sinclair_typebox.Type.String({ description: "Platform the requester is on (discord, slack, chat, etc.)" }),
-					requestingPlatformId: _sinclair_typebox.Type.String({ description: "Requester's platform-specific user ID" }),
-					preferredChannel: _sinclair_typebox.Type.Optional(_sinclair_typebox.Type.String({ description: "'sms' or 'email'" }))
-				}),
-				handler: (params) => client.requestIdentityVerification({
-					claimedIdentityId: params.claimedIdentityId,
-					requestingIdentityId: params.requestingIdentityId,
-					requestingPlatform: params.requestingPlatform,
-					requestingPlatformId: params.requestingPlatformId,
-					preferredChannel: params.preferredChannel
-				})
-			}),
-			defineTool({
-				name: "confirm_identity_verification",
-				description: "Confirm a verification by providing the three-word phrase. On success, the requesting identity is merged into the claimed identity.",
-				parameters: _sinclair_typebox.Type.Object({
-					verificationId: _sinclair_typebox.Type.String({ description: "Verification ID returned from request_identity_verification" }),
-					phrase: _sinclair_typebox.Type.String({ description: "Three-word phrase the person received via SMS or email" })
-				}),
-				handler: (params) => client.confirmIdentityVerification({
-					verificationId: params.verificationId,
-					phrase: params.phrase
-				})
-			})
-		];
-		for (const tool of tools) {
-			api.registerTool(tool);
-			identityToolNames.add(tool.name);
-		}
-		log.info(`Registered ${String(tools.length)} identity tools`);
-		api.on("message_received", async (...args) => {
-			const event = args[0];
-			const ctx = args[1];
-			const platform = ctx.channelId ?? "unknown";
-			const senderId = event.from;
-			if (!senderId) return;
-			const cacheKey = ctx.conversationId ?? `${platform}:${senderId}`;
-			const cached = getCached(cacheKey);
-			if (cached) {
-				if (!cached.accessAllowed) return {
-					block: true,
-					blockReason: "Identity: access denied for this sender"
-				};
-				return;
-			}
-			try {
-				const resolveResult = await client.resolveIdentity({
-					platform,
-					platformId: senderId
-				});
-				setCached(cacheKey, {
-					...await client.enforcePolicy({
-						platform,
-						senderId
-					}),
-					accessAllowed: resolveResult.accessAllowed
-				});
-				if (!resolveResult.accessAllowed) return {
-					block: true,
-					blockReason: "Identity: access denied for this sender"
-				};
-				log.info(`Identity resolved: ${senderId} → ${resolveResult.identityId ?? "unknown"} (${resolveResult.status})`);
-			} catch (e) {
-				log.error(`Identity resolution failed for ${senderId}: ${e.message}`);
-				if (failureMode === "closed") return {
-					block: true,
-					blockReason: "Identity: identity service unavailable — access denied (closed mode)"
-				};
-			}
-		}, { priority: 100 });
-		api.on("before_tool_call", async (...args) => {
-			const event = args[0];
-			const ctx = args[1];
-			if (identityToolNames.has(event.toolName)) return;
-			const sessionKey = ctx.sessionKey;
-			if (!sessionKey) return;
-			const perms = getCached(sessionKey);
-			if (!perms) {
-				if (failureMode === "permissive") return;
-				return {
-					block: true,
-					blockReason: "Identity: no identity context established — tool access denied"
-				};
-			}
-			if (!perms.identified) {
-				if (failureMode === "permissive") return;
-				return {
-					block: true,
-					blockReason: "Identity: unknown sender identity — tool access denied"
-				};
-			}
-			if (perms.deniedTools.includes("*") || perms.deniedTools.includes(event.toolName)) return {
-				block: true,
-				blockReason: `Identity: tool '${event.toolName}' is denied for your role`
-			};
-			if (perms.allowedTools.length > 0 && !perms.allowedTools.includes(event.toolName)) return {
-				block: true,
-				blockReason: `Identity: tool '${event.toolName}' is not in your allowed tools`
-			};
-		}, { priority: 100 });
-		api.on("after_tool_call", async (...args) => {
-			const event = args[0];
-			const sessionKey = args[1].sessionKey;
-			if (!sessionKey) return;
-			const perms = getCached(sessionKey);
-			if (!perms?.identityId) return;
-			try {
-				await client.checkToolPermission({
-					platform: "tool_audit",
-					senderId: perms.identityId,
-					toolName: event.toolName
-				});
-			} catch (e) {
-				log.error(`Audit logging failed: ${e.message}`);
-			}
-		});
-		log.info("Alfe Identity plugin activated");
-	}
-};
-//#endregion
-module.exports = plugin;
+const require_plugin = require("./plugin2.cjs");
+module.exports = require_plugin.plugin;