@agenticmail/enterprise 0.3.2 → 0.4.1

package/src/engine/agenticmail-bridge.ts

@@ -1,296 +0,0 @@
-/**
- * AgenticMail Bridge
- *
- * Integrates the enterprise engine with AgenticMail's OpenClaw plugin.
- * This is the glue code that makes enterprise features available
- * inside an agent's OpenClaw session.
- *
- * When an enterprise-managed agent boots:
- * 1. Bridge loads agent config from engine
- * 2. Registers permission middleware on every tool call
- * 3. Injects KB context before LLM calls
- * 4. Streams activity events to the engine
- * 5. Enforces rate limits and budgets
- *
- * Usage:
- *   // In OpenClaw plugin init
- *   import { createAgenticMailBridge } from '@agenticmail/enterprise/bridge';
- *   const bridge = await createAgenticMailBridge({
- *     engineUrl: process.env.AGENTICMAIL_ENTERPRISE_URL,
- *     agentId: process.env.AGENTICMAIL_AGENT_ID,
- *     orgId: process.env.AGENTICMAIL_ORG_ID,
- *   });
- *   bridge.install(openclawPlugin);
- */
-
-import { EnterpriseHook, type EnterpriseHookConfig } from './openclaw-hook.js';
-import { TOOL_INDEX, generateOpenClawToolPolicy } from './tool-catalog.js';
-
-// ─── Types ──────────────────────────────────────────────
-
-export interface BridgeConfig extends EnterpriseHookConfig {
-  /** Auto-configure tool policy on startup */
-  autoConfigureTools?: boolean;
-  
-  /** Inject coordination context about enterprise features */
-  injectCoordinationContext?: boolean;
-
-  /** Log enterprise events to console */
-  verbose?: boolean;
-}
-
-export interface ToolInterceptor {
-  /** Called before every tool invocation. Return false to block. */
-  beforeTool: (toolId: string, params: Record<string, any>, sessionId: string) => Promise<{
-    allowed: boolean;
-    reason?: string;
-    modifiedParams?: Record<string, any>;
-  }>;
-  
-  /** Called after every tool invocation */
-  afterTool: (toolId: string, params: Record<string, any>, result: any, sessionId: string) => Promise<void>;
-}
-
-// ─── Bridge ─────────────────────────────────────────────
-
-export class AgenticMailBridge {
-  private hook: EnterpriseHook;
-  private config: BridgeConfig;
-  private toolPolicy: { allowedTools: string[]; blockedTools: string[]; approvalRequired: string[] } | null = null;
-  private sessionId: string = '';
-  private rateLimiter: { count: number; resetAt: number } = { count: 0, resetAt: 0 };
-
-  constructor(config: BridgeConfig) {
-    this.config = config;
-    this.hook = new EnterpriseHook(config);
-  }
-
-  /**
-   * Initialize the bridge — load config, verify connection
-   */
-  async initialize(): Promise<{ connected: boolean; toolPolicy: any }> {
-    const connected = await this.hook.healthCheck();
-    
-    if (connected && this.config.autoConfigureTools !== false) {
-      this.toolPolicy = await this.hook.getToolPolicy();
-    }
-
-    if (this.config.verbose) {
-      console.log(`[Enterprise] Bridge initialized. Connected: ${connected}`);
-      if (this.toolPolicy) {
-        console.log(`[Enterprise] Tool policy: ${this.toolPolicy.allowedTools.length} allowed, ${this.toolPolicy.blockedTools.length} blocked`);
-      }
-    }
-
-    return { connected, toolPolicy: this.toolPolicy };
-  }
-
-  /**
-   * Get a tool interceptor that can be registered with OpenClaw
-   */
-  getInterceptor(): ToolInterceptor {
-    return {
-      beforeTool: async (toolId, params, sessionId) => {
-        this.sessionId = sessionId;
-        
-        // Quick local check first (no API call)
-        if (this.toolPolicy?.blockedTools.includes(toolId)) {
-          if (this.config.verbose) console.log(`[Enterprise] BLOCKED: ${toolId} (policy)`);
-          return { allowed: false, reason: `Tool "${toolId}" is blocked by enterprise policy` };
-        }
-
-        // Rate limit check
-        const now = Date.now();
-        if (now > this.rateLimiter.resetAt) {
-          this.rateLimiter = { count: 0, resetAt: now + 60_000 };
-        }
-        this.rateLimiter.count++;
-        // Default 120/min, will be overridden by policy
-        const limit = (this.toolPolicy as any)?.rateLimits?.toolCallsPerMinute || 120;
-        if (this.rateLimiter.count > limit) {
-          return { allowed: false, reason: `Rate limit exceeded: ${this.rateLimiter.count}/${limit} calls/min` };
-        }
-
-        // Full permission check via engine API
-        const result = await this.hook.beforeToolCall({
-          toolId, toolName: toolId, parameters: params, sessionId,
-          timestamp: new Date(),
-        });
-
-        if (this.config.verbose && !result.allowed) {
-          console.log(`[Enterprise] BLOCKED: ${toolId} — ${result.reason}`);
-        }
-
-        return {
-          allowed: result.allowed,
-          reason: result.reason,
-          modifiedParams: result.modifiedParameters,
-        };
-      },
-
-      afterTool: async (toolId, params, result, sessionId) => {
-        await this.hook.afterToolCall(
-          { toolId, toolName: toolId, parameters: params, sessionId, timestamp: new Date() },
-          {
-            success: !result?.error,
-            output: typeof result === 'string' ? result : JSON.stringify(result)?.slice(0, 500),
-            error: result?.error,
-          },
-        );
-      },
-    };
-  }
-
-  /**
-   * Get knowledge base context to inject before LLM call
-   */
-  async getKBContext(userMessage: string): Promise<string | null> {
-    return this.hook.getKnowledgeContext(userMessage);
-  }
-
-  /**
-   * Generate coordination context for the agent's system prompt
-   */
-  getCoordinationContext(): string {
-    if (!this.config.injectCoordinationContext) return '';
-
-    const blocked = this.toolPolicy?.blockedTools || [];
-    const needsApproval = this.toolPolicy?.approvalRequired || [];
-
-    let ctx = '\n<enterprise-context>\n';
-    ctx += '🏢 This agent is managed by AgenticMail Enterprise.\n';
-    
-    if (blocked.length > 0) {
-      ctx += `⛔ Blocked tools (do not attempt): ${blocked.join(', ')}\n`;
-    }
-    if (needsApproval.length > 0) {
-      ctx += `⚠️ Tools requiring human approval: ${needsApproval.join(', ')}\n`;
-      ctx += 'When using these tools, the call will pause until a human approves or denies.\n';
-    }
-
-    ctx += '</enterprise-context>\n';
-    return ctx;
-  }
-
-  /**
-   * Notify engine of session lifecycle
-   */
-  async onSessionStart(sessionId: string): Promise<void> {
-    this.sessionId = sessionId;
-    await this.hook.onSessionStart(sessionId);
-  }
-
-  async onSessionEnd(sessionId: string): Promise<void> {
-    await this.hook.onSessionEnd(sessionId);
-  }
-
-  /**
-   * Record a message in the conversation log
-   */
-  async recordMessage(role: 'user' | 'assistant' | 'system', content: string, opts?: {
-    channel?: string;
-    tokenCount?: number;
-  }): Promise<void> {
-    await this.hook.recordMessage({
-      sessionId: this.sessionId,
-      role,
-      content,
-      channel: opts?.channel,
-      tokenCount: opts?.tokenCount || Math.ceil(content.length / 4),
-    });
-  }
-
-  /**
-   * Get the loaded tool policy
-   */
-  getToolPolicy() {
-    return this.toolPolicy;
-  }
-
-  /**
-   * Generate OpenClaw-compatible config for tools.allow / tools.deny
-   * This is what gets written to the gateway config
-   */
-  getOpenClawToolConfig(): Record<string, any> {
-    if (!this.toolPolicy) return {};
-    return generateOpenClawToolPolicy(
-      this.toolPolicy.allowedTools,
-      this.toolPolicy.blockedTools,
-    );
-  }
-}
-
-// ─── Factory ────────────────────────────────────────────
-
-/**
- * Create and initialize the AgenticMail Enterprise bridge
- */
-export async function createAgenticMailBridge(config: BridgeConfig): Promise<AgenticMailBridge> {
-  const bridge = new AgenticMailBridge({
-    autoConfigureTools: true,
-    injectCoordinationContext: true,
-    verbose: false,
-    failMode: 'open',
-    permissionCacheTtlSec: 30,
-    kbMaxTokens: 2000,
-    knowledgeBaseEnabled: true,
-    activityStreamEnabled: true,
-    ...config,
-  });
-
-  await bridge.initialize();
-  return bridge;
-}
-
-/**
- * Example integration with OpenClaw plugin:
- *
- * ```typescript
- * // In @agenticmail/openclaw plugin init
- * import { createAgenticMailBridge } from '@agenticmail/enterprise/bridge';
- *
- * export async function initPlugin(openclaw) {
- *   // Check if enterprise mode is enabled
- *   const engineUrl = process.env.AGENTICMAIL_ENTERPRISE_URL;
- *   if (!engineUrl) return; // Not enterprise, skip
- *
- *   const bridge = await createAgenticMailBridge({
- *     engineUrl,
- *     agentId: process.env.AGENTICMAIL_AGENT_ID,
- *     orgId: process.env.AGENTICMAIL_ORG_ID,
- *     apiToken: process.env.AGENTICMAIL_ENTERPRISE_TOKEN,
- *   });
- *
- *   // Register tool interceptor
- *   const interceptor = bridge.getInterceptor();
- *   openclaw.onBeforeToolCall(async (tool, params, session) => {
- *     const result = await interceptor.beforeTool(tool, params, session.id);
- *     if (!result.allowed) throw new Error(`Enterprise: ${result.reason}`);
- *     return result.modifiedParams || params;
- *   });
- *
- *   openclaw.onAfterToolCall(async (tool, params, result, session) => {
- *     await interceptor.afterTool(tool, params, result, session.id);
- *   });
- *
- *   // Inject KB context before LLM
- *   openclaw.onBeforeLLM(async (messages) => {
- *     const lastUserMsg = messages.findLast(m => m.role === 'user');
- *     if (lastUserMsg) {
- *       const kbContext = await bridge.getKBContext(lastUserMsg.content);
- *       if (kbContext) {
- *         messages.push({ role: 'system', content: kbContext });
- *       }
- *     }
- *     return messages;
- *   });
- *
- *   // Add coordination context to system prompt
- *   openclaw.appendSystemPrompt(bridge.getCoordinationContext());
- *
- *   // Session lifecycle
- *   openclaw.onSessionStart((s) => bridge.onSessionStart(s.id));
- *   openclaw.onSessionEnd((s) => bridge.onSessionEnd(s.id));
- * }
- * ```
- */

package/src/engine/openclaw-hook.ts

@@ -1,371 +0,0 @@
-/**
- * OpenClaw Integration Hook
- *
- * This is the bridge between the enterprise engine and a running
- * OpenClaw instance. It intercepts every tool call, checks permissions,
- * records activity, injects knowledge base context, and enforces budgets.
- *
- * How it works:
- * 1. OpenClaw plugin registers this hook on startup
- * 2. Before every tool call → checkPermission + recordStart
- * 3. After every tool call → recordEnd + update usage
- * 4. Before every LLM call → inject KB context if relevant
- * 5. On session start/end → lifecycle events
- *
- * Usage in OpenClaw plugin:
- *   import { createEnterpriseHook } from '@agenticmail/enterprise/hook';
- *   const hook = createEnterpriseHook({ engineUrl: 'http://localhost:4444' });
- *   // Register with OpenClaw's tool pipeline
- */
-
-// ─── Types ──────────────────────────────────────────────
-
-export interface EnterpriseHookConfig {
-  /** URL of the enterprise engine API */
-  engineUrl: string;
-
-  /** Agent ID in the enterprise system */
-  agentId: string;
-
-  /** Organization ID */
-  orgId: string;
-
-  /** Auth token for engine API */
-  apiToken?: string;
-
-  /** Enable knowledge base context injection */
-  knowledgeBaseEnabled?: boolean;
-
-  /** Max tokens for KB context per turn */
-  kbMaxTokens?: number;
-
-  /** Enable real-time activity streaming */
-  activityStreamEnabled?: boolean;
-
-  /** Fail open (allow) or fail closed (deny) when engine is unreachable */
-  failMode?: 'open' | 'closed';
-
-  /** Cache permission checks for N seconds (reduces API calls) */
-  permissionCacheTtlSec?: number;
-}
-
-export interface ToolCallContext {
-  toolId: string;
-  toolName: string;
-  parameters: Record<string, any>;
-  sessionId: string;
-  timestamp?: Date;
-}
-
-export interface ToolCallResult {
-  success: boolean;
-  output?: string;
-  error?: string;
-  inputTokens?: number;
-  outputTokens?: number;
-  costUsd?: number;
-}
-
-export interface HookResult {
-  allowed: boolean;
-  reason: string;
-  requiresApproval: boolean;
-  approvalId?: string;
-  sandbox?: boolean;
-  /** Modified parameters (if hook wants to sanitize/restrict) */
-  modifiedParameters?: Record<string, any>;
-}
-
-// ─── Enterprise Hook ────────────────────────────────────
-
-export class EnterpriseHook {
-  private config: Required<EnterpriseHookConfig>;
-  private permissionCache = new Map<string, { result: HookResult; expires: number }>();
-  private pendingToolCalls = new Map<string, string>(); // callId → toolCallRecordId
-  private connected = false;
-
-  constructor(config: EnterpriseHookConfig) {
-    this.config = {
-      engineUrl: config.engineUrl,
-      agentId: config.agentId,
-      orgId: config.orgId,
-      apiToken: config.apiToken || '',
-      knowledgeBaseEnabled: config.knowledgeBaseEnabled ?? true,
-      kbMaxTokens: config.kbMaxTokens ?? 2000,
-      activityStreamEnabled: config.activityStreamEnabled ?? true,
-      failMode: config.failMode ?? 'open',
-      permissionCacheTtlSec: config.permissionCacheTtlSec ?? 30,
-    };
-  }
-
-  /**
-   * BEFORE a tool call — check permissions, record start
-   */
-  async beforeToolCall(ctx: ToolCallContext): Promise<HookResult> {
-    try {
-      // Check cache first
-      const cached = this.permissionCache.get(ctx.toolId);
-      if (cached && cached.expires > Date.now()) {
-        // Still record the call even if cached
-        await this.recordToolCallStart(ctx);
-        return cached.result;
-      }
-
-      // Check permission with engine
-      const permResult = await this.apiCall('/api/engine/permissions/check', 'POST', {
-        agentId: this.config.agentId,
-        toolId: ctx.toolId,
-      });
-
-      const result: HookResult = {
-        allowed: permResult.allowed ?? (this.config.failMode === 'open'),
-        reason: permResult.reason || 'Unknown',
-        requiresApproval: permResult.requiresApproval || false,
-        sandbox: permResult.sandbox || false,
-      };
-
-      // Cache the permission result
-      this.permissionCache.set(ctx.toolId, {
-        result,
-        expires: Date.now() + this.config.permissionCacheTtlSec * 1000,
-      });
-
-      // If approval required, create approval request and wait
-      if (result.requiresApproval && result.allowed) {
-        const approval = await this.requestApproval(ctx);
-        if (approval) {
-          result.approvalId = approval.id;
-          if (approval.status === 'denied') {
-            result.allowed = false;
-            result.reason = `Denied by ${approval.decision?.by}: ${approval.decision?.reason || 'No reason given'}`;
-          } else if (approval.status === 'expired') {
-            result.allowed = false;
-            result.reason = 'Approval request expired';
-          }
-        }
-      }
-
-      // Record the tool call start
-      if (result.allowed) {
-        await this.recordToolCallStart(ctx);
-      } else {
-        // Record blocked call
-        await this.recordActivity('tool_blocked', {
-          toolId: ctx.toolId,
-          toolName: ctx.toolName,
-          reason: result.reason,
-        });
-      }
-
-      return result;
-
-    } catch (error: any) {
-      // Engine unreachable — use fail mode
-      const allowed = this.config.failMode === 'open';
-      return {
-        allowed,
-        reason: allowed
-          ? `Engine unreachable (fail-open): ${error.message}`
-          : `Engine unreachable (fail-closed): ${error.message}`,
-        requiresApproval: false,
-      };
-    }
-  }
-
-  /**
-   * AFTER a tool call — record result, update usage
-   */
-  async afterToolCall(ctx: ToolCallContext, result: ToolCallResult): Promise<void> {
-    try {
-      // Record usage with lifecycle manager
-      await this.apiCall('/api/engine/agents/' + this.config.agentId + '/record-tool-call', 'POST', {
-        toolId: ctx.toolId,
-        tokensUsed: (result.inputTokens || 0) + (result.outputTokens || 0),
-        costUsd: result.costUsd || 0,
-        isExternalAction: this.isExternalAction(ctx.toolId),
-        error: !result.success,
-      });
-
-      // Record activity event
-      await this.recordActivity(result.success ? 'tool_call_end' : 'tool_call_error', {
-        toolId: ctx.toolId,
-        toolName: ctx.toolName,
-        success: result.success,
-        error: result.error,
-        durationMs: ctx.timestamp ? Date.now() - ctx.timestamp.getTime() : undefined,
-        inputTokens: result.inputTokens,
-        outputTokens: result.outputTokens,
-        costUsd: result.costUsd,
-      });
-    } catch {
-      // Non-blocking — don't break the agent if tracking fails
-    }
-  }
-
-  /**
-   * BEFORE an LLM call — inject knowledge base context
-   */
-  async getKnowledgeContext(userMessage: string): Promise<string | null> {
-    if (!this.config.knowledgeBaseEnabled) return null;
-
-    try {
-      const result = await this.apiCall('/api/engine/knowledge-bases/context', 'POST', {
-        agentId: this.config.agentId,
-        query: userMessage,
-        maxTokens: this.config.kbMaxTokens,
-      });
-      return result.context || null;
-    } catch {
-      return null;
-    }
-  }
-
-  /**
-   * ON session start
-   */
-  async onSessionStart(sessionId: string): Promise<void> {
-    try {
-      await this.recordActivity('session_start', { sessionId });
-    } catch { /* non-blocking */ }
-  }
-
-  /**
-   * ON session end
-   */
-  async onSessionEnd(sessionId: string): Promise<void> {
-    try {
-      await this.recordActivity('session_end', { sessionId });
-    } catch { /* non-blocking */ }
-  }
-
-  /**
-   * Record a conversation message
-   */
-  async recordMessage(opts: {
-    sessionId: string;
-    role: 'user' | 'assistant' | 'system';
-    content: string;
-    channel?: string;
-    tokenCount: number;
-  }): Promise<void> {
-    try {
-      await this.apiCall('/api/engine/activity/record-message', 'POST', {
-        agentId: this.config.agentId,
-        ...opts,
-      });
-    } catch { /* non-blocking */ }
-  }
-
-  /**
-   * Get the tool policy for this agent (used on startup to configure OpenClaw)
-   */
-  async getToolPolicy(): Promise<{
-    allowedTools: string[];
-    blockedTools: string[];
-    approvalRequired: string[];
-    rateLimits: any;
-  } | null> {
-    try {
-      return await this.apiCall(`/api/engine/permissions/${this.config.agentId}/policy`, 'GET');
-    } catch {
-      return null;
-    }
-  }
-
-  /**
-   * Check if engine is reachable
-   */
-  async healthCheck(): Promise<boolean> {
-    try {
-      const result = await this.apiCall('/health', 'GET');
-      this.connected = result.status === 'ok';
-      return this.connected;
-    } catch {
-      this.connected = false;
-      return false;
-    }
-  }
-
-  // ─── Private ──────────────────────────────────────────
-
-  private async requestApproval(ctx: ToolCallContext): Promise<any> {
-    try {
-      const result = await this.apiCall('/api/engine/approvals/request', 'POST', {
-        agentId: this.config.agentId,
-        agentName: this.config.agentId,
-        toolId: ctx.toolId,
-        toolName: ctx.toolName,
-        parameters: ctx.parameters,
-        context: `Session ${ctx.sessionId}`,
-      });
-
-      if (result.request?.id) {
-        // Wait for decision (up to 5 minutes)
-        const start = Date.now();
-        while (Date.now() - start < 300_000) {
-          await new Promise(r => setTimeout(r, 3000));
-          const check = await this.apiCall(`/api/engine/approvals/${result.request.id}`, 'GET');
-          if (check.request?.status !== 'pending') return check.request;
-        }
-        return { status: 'expired' };
-      }
-      return null;
-    } catch {
-      return null;
-    }
-  }
-
-  private async recordToolCallStart(ctx: ToolCallContext): Promise<void> {
-    if (!this.config.activityStreamEnabled) return;
-    try {
-      await this.recordActivity('tool_call_start', {
-        toolId: ctx.toolId,
-        toolName: ctx.toolName,
-        sessionId: ctx.sessionId,
-      });
-    } catch { /* non-blocking */ }
-  }
-
-  private async recordActivity(type: string, data: Record<string, any>): Promise<void> {
-    try {
-      await this.apiCall('/api/engine/activity/record', 'POST', {
-        agentId: this.config.agentId,
-        orgId: this.config.orgId,
-        type,
-        data,
-      });
-    } catch { /* non-blocking */ }
-  }
-
-  private isExternalAction(toolId: string): boolean {
-    const externalTools = [
-      'agenticmail_send', 'agenticmail_reply', 'agenticmail_forward',
-      'agenticmail_sms_send', 'message', 'tts',
-    ];
-    return externalTools.includes(toolId);
-  }
-
-  private async apiCall(path: string, method: string, body?: any): Promise<any> {
-    const opts: RequestInit = {
-      method,
-      headers: {
-        'Content-Type': 'application/json',
-        ...(this.config.apiToken ? { 'Authorization': `Bearer ${this.config.apiToken}` } : {}),
-      },
-      signal: AbortSignal.timeout(5000),
-    };
-    if (body && method !== 'GET') opts.body = JSON.stringify(body);
-
-    const resp = await fetch(`${this.config.engineUrl}${path}`, opts);
-    return resp.json();
-  }
-}
-
-// ─── Factory ────────────────────────────────────────────
-
-/**
- * Create an enterprise hook instance for use in OpenClaw plugins
- */
-export function createEnterpriseHook(config: EnterpriseHookConfig): EnterpriseHook {
-  return new EnterpriseHook(config);
-}

package/start-live.mjs

@@ -1,39 +0,0 @@
-import { createAdapter, createServer } from './dist/index.js';
-import { randomUUID } from 'crypto';
-
-const db = await createAdapter({ type: 'sqlite', connectionString: './enterprise-live-test.db' });
-await db.migrate();
-console.log('✅ DB migrated');
-
-// Check if admin already exists
-let user = await db.getUserByEmail('ope@agenticmail.io');
-if (!user) {
-  user = await db.createUser({
-    email: 'ope@agenticmail.io',
-    name: 'Ope Olatunji',
-    role: 'owner',
-    password: 'Enterprise2026!',
-  });
-  console.log('✅ Admin created:', user.id);
-} else {
-  console.log('✅ Admin exists:', user.id);
-}
-
-await db.updateSettings({ name: 'AgenticMail', subdomain: 'agenticmail', domain: 'agenticmail.io' });
-console.log('✅ Company: AgenticMail / agenticmail.io');
-
-const key = await db.createApiKey({ name: 'live-key', createdBy: user.id, scopes: ['read', 'write', 'admin'] });
-console.log('✅ API Key:', key.plaintext);
-
-const jwtSecret = randomUUID() + randomUUID();
-const server = createServer({ port: 3200, db, jwtSecret, corsOrigins: ['*'], rateLimit: 200 });
-await server.start();
-
-console.log('');
-console.log('Login: ope@agenticmail.io / Enterprise2026!');
-console.log('Key:  ', key.plaintext);
-
-// Keep process alive
-process.on('SIGINT', () => { console.log('\nShutting down...'); process.exit(0); });
-process.on('SIGTERM', () => { console.log('\nShutting down...'); process.exit(0); });
-setInterval(() => {}, 60000);