@agenticmail/enterprise 0.5.326 → 0.5.328

package/src/agent-tools/tools/write.ts

@@ -1,68 +0,0 @@
-/**
- * AgenticMail Agent Tools — Write
- *
- * Write content to a file with directory creation, path sandbox enforcement,
- * and file size limits.
- */
-
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import type { AnyAgentTool, ToolCreationOptions } from '../types.js';
-import { readStringParam, textResult, errorResult } from '../common.js';
-import type { PathSandbox } from '../security.js';
-
-const DEFAULT_MAX_WRITE_SIZE = 5 * 1024 * 1024; // 5MB
-
-export function createWriteTool(options?: ToolCreationOptions & { pathSandbox?: PathSandbox }): AnyAgentTool {
-  var sandbox = options?.pathSandbox;
-
-  return {
-    name: 'write',
-    label: 'Write File',
-    description: 'Write content to a file. Creates the file if it does not exist. Creates parent directories as needed. Overwrites existing content.',
-    category: 'file',
-    risk: 'medium',
-    parameters: {
-      type: 'object',
-      properties: {
-        file_path: { type: 'string', description: 'Absolute path to the file to write.' },
-        content: { type: 'string', description: 'Content to write to the file.' },
-      },
-      required: ['file_path', 'content'],
-    },
-    execute: async function(_toolCallId, args) {
-      var params = args as Record<string, unknown>;
-      var filePath = readStringParam(params, 'file_path', { required: true });
-      var content = readStringParam(params, 'content', { required: true, allowEmpty: true, trim: false });
-
-      if (!path.isAbsolute(filePath) && options?.workspaceDir) {
-        filePath = path.resolve(options.workspaceDir, filePath);
-      }
-
-      // Path sandbox enforcement
-      if (sandbox) {
-        try {
-          sandbox.validate(filePath);
-        } catch (err: any) {
-          return errorResult('Access denied: ' + (err.message || 'path blocked by security policy'));
-        }
-      }
-
-      // File size limit
-      var contentBytes = Buffer.byteLength(content, 'utf-8');
-      if (contentBytes > DEFAULT_MAX_WRITE_SIZE) {
-        return errorResult('Content too large: ' + Math.round(contentBytes / 1024 / 1024) + 'MB. Maximum write size is 5MB.');
-      }
-
-      try {
-        var dir = path.dirname(filePath);
-        await fs.mkdir(dir, { recursive: true });
-        await fs.writeFile(filePath, content, 'utf-8');
-        var lines = content.split('\n').length;
-        return textResult('Wrote ' + lines + ' lines to ' + filePath);
-      } catch (err: any) {
-        return errorResult('Failed to write file: ' + (err.message || filePath));
-      }
-    },
-  };
-}

package/src/agent-tools/types.ts

@@ -1,214 +0,0 @@
-/**
- * AgenticMail Agent Tools — Core Types
- *
- * Defines the tool interface used by AI agents in the AgenticMail platform.
- * Inspired by the MCP tool protocol but simplified for internal use.
- */
-
-/** Result content block — text or image */
-export type ToolContentBlock =
-  | { type: 'text'; text: string }
-  | { type: 'image'; data: string; mimeType: string };
-
-/** Result returned by a tool execution */
-export interface ToolResult<T = unknown> {
-  content: ToolContentBlock[];
-  details?: T;
-}
-
-/** JSON Schema definition for tool parameters */
-export interface ToolParameterSchema {
-  type: 'object';
-  properties: Record<string, {
-    type: string;
-    description?: string;
-    default?: unknown;
-    enum?: string[];
-    minimum?: number;
-    maximum?: number;
-    minLength?: number;
-    maxLength?: number;
-    items?: Record<string, any>;
-    properties?: Record<string, any>;
-    required?: string[];
-  }>;
-  required?: string[];
-}
-
-/** A single agent tool definition */
-export interface AgentTool<TParams = Record<string, unknown>, TResult = unknown> {
-  /** Unique tool name (snake_case) */
-  name: string;
-  /** Human-readable label for UI display */
-  label?: string;
-  /** What this tool does */
-  description: string;
-  /** JSON Schema for parameters */
-  parameters?: ToolParameterSchema;
-  /** MCP-style schema (alias for parameters) */
-  input_schema?: Record<string, any>;
-  /** Execute the tool with given parameters */
-  execute: (toolCallId: string, params: TParams) => Promise<ToolResult<TResult>>;
-  /** Whether this tool is restricted to agent owner */
-  ownerOnly?: boolean;
-  /** Category for grouping in UI */
-  category?: 'file' | 'web' | 'search' | 'command' | 'browser' | 'memory' | 'utility' | 'communication' | 'productivity' | 'email' | 'calendar' | 'enterprise';
-  /** Risk level */
-  risk?: 'low' | 'medium' | 'high' | 'critical';
-}
-
-/** Shorthand for any tool regardless of param/result types */
-export type AnyAgentTool = AgentTool<any, unknown>;
-
-/** Audit sink interface for tool execution logging */
-export interface AuditSink {
-  log(entry: {
-    traceId: string;
-    toolName: string;
-    toolCallId: string;
-    agentId: string;
-    timestamp: string;
-    params: Record<string, unknown>;
-    durationMs: number;
-    success: boolean;
-    error?: string;
-    outputSize?: number;
-  }): void;
-}
-
-/** Telemetry sink interface for tool metrics */
-export interface TelemetrySink {
-  record(entry: {
-    toolName: string;
-    agentId: string;
-    durationMs: number;
-    success: boolean;
-    outputSize: number;
-    timestamp: string;
-  }): void;
-}
-
-/** Configuration passed when creating tools */
-export interface ToolCreationOptions {
-  /** Working directory for file operations */
-  workspaceDir?: string;
-  /** Whether the agent is sandboxed */
-  sandboxed?: boolean;
-  /** Unique agent identifier for audit + rate limiting */
-  agentId?: string;
-  /** Runtime reference for features that need session interaction (e.g., meeting monitor) */
-  runtimeRef?: {
-    /** Send a message into an active session */
-    sendMessage?: (sessionId: string, message: string) => Promise<void>;
-    /** Get the session ID for the current tool execution context */
-    getCurrentSessionId?: () => string | undefined;
-    /** Mark a session as keep-alive (prevents completion on end_turn) */
-    setKeepAlive?: (sessionId: string, keepAlive: boolean) => void;
-  };
-  /** AgenticMail tool-specific config overrides */
-  config?: AgenticMailToolConfig;
-  /** Security sandbox configuration */
-  security?: {
-    pathSandbox?: {
-      enabled?: boolean;
-      allowedDirs?: string[];
-      blockedPatterns?: string[];
-    };
-    ssrf?: {
-      enabled?: boolean;
-      allowedHosts?: string[];
-      blockedCidrs?: string[];
-    };
-    commandSanitizer?: {
-      enabled?: boolean;
-      mode?: 'blocklist' | 'allowlist';
-      allowedCommands?: string[];
-      blockedPatterns?: string[];
-    };
-  };
-  /** Engine database reference for tools that need DB access */
-  engineDb?: any;
-  /** Database Connection Manager for enterprise database access */
-  databaseManager?: any;
-  /** Middleware configuration for cross-cutting concerns */
-  middleware?: {
-    audit?: {
-      enabled?: boolean;
-      sink?: AuditSink;
-      redactKeys?: string[];
-    };
-    rateLimit?: {
-      enabled?: boolean;
-      overrides?: Record<string, { maxTokens: number; refillRate: number }>;
-    };
-    circuitBreaker?: {
-      enabled?: boolean;
-    };
-    telemetry?: {
-      enabled?: boolean;
-      sink?: TelemetrySink;
-    };
-  };
-}
-
-/** Tool-level configuration */
-export interface AgenticMailToolConfig {
-  web?: {
-    fetch?: {
-      enabled?: boolean;
-      maxChars?: number;
-      maxCharsCap?: number;
-      maxResponseBytes?: number;
-      maxRedirects?: number;
-      timeoutSeconds?: number;
-      cacheTtlMinutes?: number;
-      readability?: boolean;
-      userAgent?: string;
-      firecrawl?: {
-        enabled?: boolean;
-        apiKey?: string;
-        baseUrl?: string;
-        onlyMainContent?: boolean;
-        maxAgeMs?: number;
-        timeoutSeconds?: number;
-      };
-    };
-    search?: {
-      enabled?: boolean;
-      provider?: 'brave' | 'perplexity' | 'grok';
-      apiKey?: string;
-      maxResults?: number;
-      timeoutSeconds?: number;
-      cacheTtlMinutes?: number;
-      perplexity?: {
-        apiKey?: string;
-        baseUrl?: string;
-        model?: string;
-      };
-      grok?: {
-        apiKey?: string;
-        model?: string;
-        inlineCitations?: boolean;
-      };
-    };
-  };
-  bash?: {
-    enabled?: boolean;
-    timeoutMs?: number;
-    maxOutputBytes?: number;
-    allowedCommands?: string[];
-    blockedCommands?: string[];
-  };
-  browser?: {
-    enabled?: boolean;
-    headless?: boolean;
-    timeoutMs?: number;
-  };
-  memory?: {
-    enabled?: boolean;
-    backend?: 'local' | 'sqlite' | 'vector';
-  };
-}
-
-/** Re-export ToolDefinition from skills for convenience */
-export type { ToolDefinition } from '../engine/skills.js';

package/src/agenticmail/index.ts

@@ -1,34 +0,0 @@
-/**
- * AgenticMail Enterprise
- *
- * Embedded email & communication system for enterprise agents.
- * No separate server — agents use their org email via OAuth.
- *
- * Usage:
- *   import { AgenticMailManager } from './agenticmail/index.js';
- *   const mail = new AgenticMailManager({ db: engineDb });
- *   await mail.registerAgent({ agentId, email, accessToken, provider: 'microsoft', ... });
- *   const provider = mail.getProvider(agentId);
- *   await provider.send({ to: 'user@company.com', subject: 'Hello', body: '...' });
- */
-
-export { AgenticMailManager } from './manager.js';
-export type { AgenticMailManagerOptions } from './manager.js';
-export { createEmailProvider } from './providers/index.js';
-export { MicrosoftEmailProvider } from './providers/microsoft.js';
-export { GoogleEmailProvider } from './providers/google.js';
-export { ImapEmailProvider, IMAP_PRESETS, detectImapSettings } from './providers/imap.js';
-export type { ImapEmailIdentity } from './providers/imap.js';
-export type {
-  IEmailProvider,
-  AgentEmailIdentity,
-  EmailProvider,
-  EmailMessage,
-  EmailEnvelope,
-  EmailFolder,
-  SendEmailOptions,
-  SearchCriteria,
-  EmailAttachment,
-  AgentMessage,
-  AgentTask,
-} from './types.js';

package/src/agenticmail/manager.ts

@@ -1,253 +0,0 @@
-/**
- * AgenticMail Enterprise Manager
- *
- * Central orchestrator that connects agents to their org email.
- * Manages email provider instances per agent and provides the
- * tool handler interface for the enterprise agent system.
- *
- * Architecture:
- *   Agent (from org directory via OAuth)
- *     → AgenticMailManager.getProvider(agentId)
- *       → IEmailProvider (Microsoft Graph / Gmail API)
- *         → Org's email system
- *
- * No separate AgenticMail server. No API keys. No relay setup.
- * The agent IS the org identity.
- */
-
-import type { EngineDatabase } from '../engine/db-adapter.js';
-import type {
-  IEmailProvider, AgentEmailIdentity, EmailProvider,
-  AgentMessage, AgentTask,
-} from './types.js';
-import { createEmailProvider } from './providers/index.js';
-
-export interface AgenticMailManagerOptions {
-  db?: EngineDatabase;
-}
-
-export class AgenticMailManager {
-  private providers = new Map<string, IEmailProvider>();
-  private identities = new Map<string, AgentEmailIdentity>();
-  private db?: EngineDatabase;
-
-  constructor(opts?: AgenticMailManagerOptions) {
-    this.db = opts?.db;
-  }
-
-  setDb(db: EngineDatabase): void {
-    this.db = db;
-  }
-
-  // ─── Agent Registration ─────────────────────────────
-
-  /**
-   * Register an agent's email identity from the org's OAuth/SSO.
-   * Called when an agent is created or when its OAuth token is refreshed.
-   */
-  async registerAgent(identity: AgentEmailIdentity): Promise<void> {
-    this.identities.set(identity.agentId, identity);
-
-    // Create and connect the email provider
-    const provider = createEmailProvider(identity.provider);
-    await provider.connect(identity);
-    this.providers.set(identity.agentId, provider);
-  }
-
-  /**
-   * Unregister an agent (on deletion or token revocation).
-   */
-  async unregisterAgent(agentId: string): Promise<void> {
-    const provider = this.providers.get(agentId);
-    if (provider) {
-      await provider.disconnect().catch(() => {});
-      this.providers.delete(agentId);
-    }
-    this.identities.delete(agentId);
-  }
-
-  /**
-   * Get the email provider for an agent.
-   * Throws if agent is not registered.
-   */
-  getProvider(agentId: string): IEmailProvider {
-    const provider = this.providers.get(agentId);
-    if (!provider) throw new Error(`Agent ${agentId} has no email provider registered. Ensure the agent has been connected via org OAuth.`);
-    return provider;
-  }
-
-  /**
-   * Get the email identity for an agent.
-   */
-  getIdentity(agentId: string): AgentEmailIdentity | undefined {
-    return this.identities.get(agentId);
-  }
-
-  /**
-   * Check if an agent has email access.
-   */
-  hasEmail(agentId: string): boolean {
-    return this.providers.has(agentId);
-  }
-
-  // ─── Inter-Agent Messaging ──────────────────────────
-  // These use the enterprise DB directly, not email.
-  // Agents in the same org can message each other without email.
-
-  /**
-   * Send a message from one agent to another (internal, no email).
-   */
-  async sendAgentMessage(from: string, to: string, subject: string, body: string, priority: 'normal' | 'high' | 'urgent' = 'normal'): Promise<AgentMessage> {
-    const msg: AgentMessage = {
-      id: crypto.randomUUID(),
-      from,
-      to,
-      subject,
-      body,
-      priority,
-      createdAt: new Date().toISOString(),
-      read: false,
-    };
-
-    if (this.db) {
-      await this.db.execute(
-        `INSERT INTO agent_messages (id, from_agent, to_agent, subject, body, priority, created_at, read)
-         VALUES (?, ?, ?, ?, ?, ?, ?, 0)`,
-        [msg.id, msg.from, msg.to, msg.subject, msg.body, msg.priority, msg.createdAt]
-      ).catch(() => {});
-    }
-
-    return msg;
-  }
-
-  /**
-   * Get unread messages for an agent.
-   */
-  async getAgentMessages(agentId: string, opts?: { unreadOnly?: boolean; limit?: number }): Promise<AgentMessage[]> {
-    if (!this.db) return [];
-    try {
-      let sql = 'SELECT * FROM agent_messages WHERE to_agent = ?';
-      const params: any[] = [agentId];
-      if (opts?.unreadOnly) {
-        sql += ' AND read = 0';
-      }
-      sql += ' ORDER BY created_at DESC LIMIT ?';
-      params.push(opts?.limit || 20);
-
-      const rows = await this.db.query<any>(sql, params);
-      return rows.map((r: any) => ({
-        id: r.id,
-        from: r.from_agent,
-        to: r.to_agent,
-        subject: r.subject,
-        body: r.body,
-        priority: r.priority,
-        createdAt: r.created_at,
-        read: !!r.read,
-      }));
-    } catch {
-      return [];
-    }
-  }
-
-  // ─── Task Management ────────────────────────────────
-  // Tasks also use the enterprise DB directly.
-
-  /**
-   * Create a task assigned to an agent.
-   */
-  async createTask(assigner: string, assignee: string, title: string, description?: string, priority: 'low' | 'normal' | 'high' | 'urgent' = 'normal'): Promise<AgentTask> {
-    const now = new Date().toISOString();
-    const task: AgentTask = {
-      id: crypto.randomUUID(),
-      assigner,
-      assignee,
-      title,
-      description,
-      status: 'pending',
-      priority,
-      createdAt: now,
-      updatedAt: now,
-    };
-
-    if (this.db) {
-      await this.db.execute(
-        `INSERT INTO agent_tasks (id, assigner, assignee, title, description, status, priority, created_at, updated_at)
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-        [task.id, task.assigner, task.assignee, task.title, task.description || null, task.status, task.priority, task.createdAt, task.updatedAt]
-      ).catch(() => {});
-    }
-
-    return task;
-  }
-
-  /**
-   * Get tasks for an agent.
-   */
-  async getAgentTasks(agentId: string, direction: 'incoming' | 'outgoing' = 'incoming', status?: string): Promise<AgentTask[]> {
-    if (!this.db) return [];
-    try {
-      const col = direction === 'incoming' ? 'assignee' : 'assigner';
-      let sql = `SELECT * FROM agent_tasks WHERE ${col} = ?`;
-      const params: any[] = [agentId];
-      if (status) {
-        sql += ' AND status = ?';
-        params.push(status);
-      }
-      sql += ' ORDER BY created_at DESC LIMIT 50';
-
-      const rows = await this.db.query<any>(sql, params);
-      return rows.map((r: any) => ({
-        id: r.id,
-        assigner: r.assigner,
-        assignee: r.assignee,
-        title: r.title,
-        description: r.description,
-        status: r.status,
-        priority: r.priority,
-        result: r.result ? JSON.parse(r.result) : undefined,
-        createdAt: r.created_at,
-        updatedAt: r.updated_at,
-      }));
-    } catch {
-      return [];
-    }
-  }
-
-  /**
-   * Update task status.
-   */
-  async updateTask(taskId: string, updates: { status?: string; result?: any }): Promise<void> {
-    if (!this.db) return;
-    const sets: string[] = ['updated_at = ?'];
-    const params: any[] = [new Date().toISOString()];
-    if (updates.status) { sets.push('status = ?'); params.push(updates.status); }
-    if (updates.result !== undefined) { sets.push('result = ?'); params.push(JSON.stringify(updates.result)); }
-    params.push(taskId);
-    await this.db.execute(`UPDATE agent_tasks SET ${sets.join(', ')} WHERE id = ?`, params).catch(() => {});
-  }
-
-  // ─── Lifecycle ──────────────────────────────────────
-
-  /**
-   * Get all registered agents and their email status.
-   */
-  getRegisteredAgents(): { agentId: string; email: string; provider: EmailProvider }[] {
-    const agents: { agentId: string; email: string; provider: EmailProvider }[] = [];
-    for (const [agentId, identity] of this.identities) {
-      agents.push({ agentId, email: identity.email, provider: identity.provider });
-    }
-    return agents;
-  }
-
-  /**
-   * Shutdown — disconnect all providers.
-   */
-  async shutdown(): Promise<void> {
-    for (const provider of this.providers.values()) {
-      await provider.disconnect().catch(() => {});
-    }
-    this.providers.clear();
-    this.identities.clear();
-  }
-}