@agenticmail/enterprise 0.5.111 → 0.5.112

package/dist/cli-agent-NOX4LJ62.js

@@ -0,0 +1,306 @@
+import "./chunk-KFQGP6VL.js";
+
+// src/cli-agent.ts
+import { Hono } from "hono";
+import { serve } from "@hono/node-server";
+async function runAgent(_args) {
+  const DATABASE_URL = process.env.DATABASE_URL;
+  const JWT_SECRET = process.env.JWT_SECRET;
+  const AGENT_ID = process.env.AGENTICMAIL_AGENT_ID;
+  const PORT = parseInt(process.env.PORT || "3000", 10);
+  if (!DATABASE_URL) {
+    console.error("ERROR: DATABASE_URL is required");
+    process.exit(1);
+  }
+  if (!JWT_SECRET) {
+    console.error("ERROR: JWT_SECRET is required");
+    process.exit(1);
+  }
+  if (!AGENT_ID) {
+    console.error("ERROR: AGENTICMAIL_AGENT_ID is required");
+    process.exit(1);
+  }
+  console.log("\u{1F916} AgenticMail Agent Runtime");
+  console.log(`   Agent ID: ${AGENT_ID}`);
+  console.log("   Connecting to database...");
+  const { createAdapter } = await import("./factory-GT6SUZSQ.js");
+  const db = await createAdapter({
+    type: DATABASE_URL.startsWith("postgres") ? "postgres" : "sqlite",
+    connectionString: DATABASE_URL
+  });
+  await db.migrate();
+  const { EngineDatabase } = await import("./db-adapter-65QMSGCB.js");
+  const engineDbInterface = db.getEngineDB();
+  if (!engineDbInterface) {
+    console.error("ERROR: Database does not support engine queries");
+    process.exit(1);
+  }
+  const adapterDialect = db.getDialect();
+  const dialectMap = {
+    sqlite: "sqlite",
+    postgres: "postgres",
+    supabase: "postgres",
+    neon: "postgres",
+    cockroachdb: "postgres"
+  };
+  const engineDialect = dialectMap[adapterDialect] || adapterDialect;
+  const engineDb = new EngineDatabase(engineDbInterface, engineDialect);
+  await engineDb.migrate();
+  const agentRow = await engineDb.query(
+    `SELECT id, name, display_name, config, state FROM managed_agents WHERE id = $1`,
+    [AGENT_ID]
+  );
+  if (!agentRow || agentRow.length === 0) {
+    console.error(`ERROR: Agent ${AGENT_ID} not found in database`);
+    process.exit(1);
+  }
+  const agent = agentRow[0];
+  console.log(`   Agent: ${agent.display_name || agent.name}`);
+  console.log(`   State: ${agent.state}`);
+  const { AgentLifecycleManager } = await import("./lifecycle-RHPPFTH7.js");
+  const lifecycle = new AgentLifecycleManager({ db: engineDb });
+  await lifecycle.loadFromDb();
+  const managed = lifecycle.getAgent(AGENT_ID);
+  if (!managed) {
+    console.error(`ERROR: Could not load agent ${AGENT_ID} from lifecycle`);
+    process.exit(1);
+  }
+  const config = managed.config;
+  console.log(`   Model: ${config.model?.provider}/${config.model?.modelId}`);
+  let memoryManager;
+  try {
+    const { AgentMemoryManager } = await import("./agent-memory-G7YFTMDO.js");
+    memoryManager = new AgentMemoryManager(engineDb);
+    console.log("   Memory: DB-backed");
+  } catch {
+    console.log("   Memory: file-based fallback");
+  }
+  try {
+    const settings = await db.getSettings();
+    const keys = settings?.modelPricingConfig?.providerApiKeys;
+    if (keys && typeof keys === "object") {
+      const { PROVIDER_REGISTRY } = await import("./providers-DZDNNJTY.js");
+      for (const [providerId, apiKey] of Object.entries(keys)) {
+        const envVar = PROVIDER_REGISTRY[providerId]?.envKey;
+        if (envVar && apiKey && !process.env[envVar]) {
+          process.env[envVar] = apiKey;
+          console.log(`   \u{1F511} Loaded API key for ${providerId}`);
+        }
+      }
+    }
+  } catch {
+  }
+  const { createAgentRuntime } = await import("./runtime-GBC7BO3X.js");
+  const getEmailConfig = (agentId) => {
+    const m = lifecycle.getAgent(agentId);
+    return m?.config?.emailConfig || null;
+  };
+  const onTokenRefresh = (agentId, tokens) => {
+    const m = lifecycle.getAgent(agentId);
+    if (m?.config?.emailConfig) {
+      if (tokens.accessToken) m.config.emailConfig.oauthAccessToken = tokens.accessToken;
+      if (tokens.refreshToken) m.config.emailConfig.oauthRefreshToken = tokens.refreshToken;
+      if (tokens.expiresAt) m.config.emailConfig.oauthTokenExpiry = tokens.expiresAt;
+      lifecycle.saveAgent(agentId).catch(() => {
+      });
+    }
+  };
+  let defaultModel;
+  const modelStr = process.env.AGENTICMAIL_MODEL || `${config.model?.provider}/${config.model?.modelId}`;
+  if (modelStr && modelStr.includes("/")) {
+    const [provider, ...rest] = modelStr.split("/");
+    defaultModel = {
+      provider,
+      modelId: rest.join("/"),
+      thinkingLevel: process.env.AGENTICMAIL_THINKING || config.model?.thinkingLevel
+    };
+  }
+  const runtime = createAgentRuntime({
+    engineDb,
+    adminDb: db,
+    defaultModel,
+    apiKeys: {},
+    gatewayEnabled: true,
+    getEmailConfig,
+    onTokenRefresh,
+    agentMemoryManager: memoryManager,
+    resumeOnStartup: true
+  });
+  await runtime.start();
+  const runtimeApp = runtime.getApp();
+  const app = new Hono();
+  app.get("/health", (c) => c.json({
+    status: "ok",
+    agentId: AGENT_ID,
+    agentName: agent.display_name || agent.name,
+    uptime: process.uptime()
+  }));
+  app.get("/ready", (c) => c.json({ ready: true, agentId: AGENT_ID }));
+  if (runtimeApp) {
+    app.route("/api/runtime", runtimeApp);
+  }
+  serve({ fetch: app.fetch, port: PORT }, (info) => {
+    console.log(`
+\u2705 Agent runtime started`);
+    console.log(`   Health: http://localhost:${info.port}/health`);
+    console.log(`   Runtime: http://localhost:${info.port}/api/runtime`);
+    console.log("");
+  });
+  const shutdown = () => {
+    console.log("\n\u23F3 Shutting down agent...");
+    runtime.stop().then(() => db.disconnect()).then(() => {
+      console.log("\u2705 Agent shutdown complete");
+      process.exit(0);
+    });
+    setTimeout(() => process.exit(1), 1e4).unref();
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  try {
+    await engineDb.query(
+      `UPDATE managed_agents SET state = 'running', updated_at = $1 WHERE id = $2`,
+      [(/* @__PURE__ */ new Date()).toISOString(), AGENT_ID]
+    );
+    console.log("   State: running");
+  } catch {
+  }
+  setTimeout(async () => {
+    try {
+      const orgRows = await engineDb.query(
+        `SELECT org_id FROM managed_agents WHERE id = $1`,
+        [AGENT_ID]
+      );
+      const orgId = orgRows?.[0]?.org_id;
+      if (!orgId) {
+        console.log("[onboarding] No org ID found, skipping");
+        return;
+      }
+      const pendingRows = await engineDb.query(
+        `SELECT r.id, r.policy_id, p.name as policy_name, p.content as policy_content, p.priority
+         FROM onboarding_records r
+         JOIN org_policies p ON r.policy_id = p.id
+         WHERE r.agent_id = $1 AND r.status = 'pending'`,
+        [AGENT_ID]
+      );
+      if (!pendingRows || pendingRows.length === 0) {
+        console.log("[onboarding] Already complete or no records");
+      } else {
+        console.log(`[onboarding] ${pendingRows.length} pending policies \u2014 auto-acknowledging...`);
+        const ts = (/* @__PURE__ */ new Date()).toISOString();
+        const policyNames = [];
+        for (const row of pendingRows) {
+          const policyName = row.policy_name || row.policy_id;
+          policyNames.push(policyName);
+          console.log(`[onboarding] Reading: ${policyName}`);
+          const { createHash } = await import("crypto");
+          const hash = createHash("sha256").update(row.policy_content || "").digest("hex").slice(0, 16);
+          await engineDb.query(
+            `UPDATE onboarding_records SET status = 'acknowledged', acknowledged_at = $1, verification_hash = $2, updated_at = $1 WHERE id = $3`,
+            [ts, hash, row.id]
+          );
+          console.log(`[onboarding] \u2705 Acknowledged: ${policyName}`);
+          if (memoryManager) {
+            try {
+              await memoryManager.storeMemory(AGENT_ID, {
+                content: `Organization policy "${policyName}" (${row.priority}): ${(row.policy_content || "").slice(0, 500)}`,
+                category: "org_knowledge",
+                importance: row.priority === "mandatory" ? "high" : "medium",
+                confidence: 1
+              });
+            } catch {
+            }
+          }
+        }
+        if (memoryManager) {
+          try {
+            await memoryManager.storeMemory(AGENT_ID, {
+              content: `Completed onboarding: read and acknowledged ${policyNames.length} organization policies: ${policyNames.join(", ")}.`,
+              category: "org_knowledge",
+              importance: "high",
+              confidence: 1
+            });
+          } catch {
+          }
+        }
+        console.log(`[onboarding] \u2705 Onboarding complete \u2014 ${policyNames.length} policies acknowledged`);
+      }
+      const managerEmail = config.managerEmail || (config.manager?.type === "external" ? config.manager.email : null);
+      const emailConfig = config.emailConfig;
+      if (managerEmail && emailConfig) {
+        console.log(`[welcome] Sending introduction email to ${managerEmail}...`);
+        try {
+          const { createEmailProvider } = await import("./agenticmail-TQQF7BI4.js");
+          const providerType = emailConfig.provider || (emailConfig.oauthProvider === "google" ? "google" : emailConfig.oauthProvider === "microsoft" ? "microsoft" : "imap");
+          const emailProvider = createEmailProvider(providerType);
+          await emailProvider.connect({
+            agentId: AGENT_ID,
+            email: emailConfig.email || config.email?.address || "",
+            oauthAccessToken: emailConfig.oauthAccessToken,
+            oauthRefreshToken: emailConfig.oauthRefreshToken,
+            oauthClientId: emailConfig.oauthClientId,
+            oauthClientSecret: emailConfig.oauthClientSecret,
+            oauthTokenExpiry: emailConfig.oauthTokenExpiry,
+            imapHost: emailConfig.imapHost,
+            imapPort: emailConfig.imapPort,
+            smtpHost: emailConfig.smtpHost,
+            smtpPort: emailConfig.smtpPort,
+            password: emailConfig.password
+          });
+          const agentName = config.displayName || config.name;
+          const role = config.identity?.role || "AI Agent";
+          const traits = config.identity?.traits || {};
+          const traitLines = Object.entries(traits).filter(([, v]) => v).map(([k, v]) => `  - ${k}: ${v}`).join("\n");
+          const policyCount = pendingRows?.length || 0;
+          const body = `Hello,
+
+I'm ${agentName}, your new ${role}. I've just been deployed and have completed my onboarding \u2014 I've read and acknowledged all ${policyCount} organization policies.
+
+About me:
+- Role: ${role}
+- Communication style: ${config.identity?.tone || "professional"}
+- Language: ${config.identity?.language || "English"}
+${traitLines ? `- Personality traits:
+${traitLines}` : ""}
+
+I'm ready to start working. Here's what I can help with:
+- Responding to emails and communications
+- Processing tasks and requests
+- Following organization guidelines and escalation protocols
+
+You can reach me by email at ${config.email?.address || emailConfig?.email || "my configured email address"}, or through the enterprise dashboard.
+
+Looking forward to working with you!
+
+Best regards,
+${agentName}`;
+          await emailProvider.send({
+            to: managerEmail,
+            subject: `Hi! I'm ${agentName}, your new ${role}`,
+            text: body
+          });
+          console.log(`[welcome] \u2705 Welcome email sent to ${managerEmail}`);
+          if (memoryManager) {
+            try {
+              await memoryManager.storeMemory(AGENT_ID, {
+                content: `Sent welcome introduction email to manager at ${managerEmail}. Introduced myself as ${agentName}, ${role}.`,
+                category: "interaction_pattern",
+                importance: "medium",
+                confidence: 1
+              });
+            } catch {
+            }
+          }
+        } catch (err) {
+          console.error(`[welcome] Failed to send welcome email: ${err.message}`);
+        }
+      } else {
+        if (!managerEmail) console.log("[welcome] No manager email configured, skipping welcome email");
+      }
+    } catch (err) {
+      console.error(`[onboarding] Error: ${err.message}`);
+    }
+  }, 3e3);
+}
+export {
+  runAgent
+};

package/dist/cli.js

@@ -50,7 +50,7 @@ Skill Development:
     import("./cli-serve-25MJKRJM.js").then((m) => m.runServe(args.slice(1))).catch(fatal);
     break;
   case "agent":
-    import("./cli-agent-FSHCUSU5.js").then((m) => m.runAgent(args.slice(1))).catch(fatal);
+    import("./cli-agent-NOX4LJ62.js").then((m) => m.runAgent(args.slice(1))).catch(fatal);
     break;
   case "setup":
   default:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agenticmail/enterprise",
-  "version": "0.5.111",
+  "version": "0.5.112",
   "description": "AgenticMail Enterprise — cloud-hosted AI agent identity, email, auth & compliance for organizations",
   "type": "module",
   "bin": {

package/src/cli-agent.ts

@@ -277,7 +277,24 @@ export async function runAgent(_args: string[]) {
         console.log(`[welcome] Sending introduction email to ${managerEmail}...`);
         try {
           const { createEmailProvider } = await import('./agenticmail/index.js');
-          const emailProvider = await createEmailProvider(emailConfig);
+          // Determine provider type from emailConfig
+          const providerType = emailConfig.provider || (emailConfig.oauthProvider === 'google' ? 'google' : emailConfig.oauthProvider === 'microsoft' ? 'microsoft' : 'imap');
+          const emailProvider = createEmailProvider(providerType);
+          // Connect with agent's email identity
+          await emailProvider.connect({
+            agentId: AGENT_ID,
+            email: emailConfig.email || config.email?.address || '',
+            oauthAccessToken: emailConfig.oauthAccessToken,
+            oauthRefreshToken: emailConfig.oauthRefreshToken,
+            oauthClientId: emailConfig.oauthClientId,
+            oauthClientSecret: emailConfig.oauthClientSecret,
+            oauthTokenExpiry: emailConfig.oauthTokenExpiry,
+            imapHost: emailConfig.imapHost,
+            imapPort: emailConfig.imapPort,
+            smtpHost: emailConfig.smtpHost,
+            smtpPort: emailConfig.smtpPort,
+            password: emailConfig.password,
+          });
 
           const agentName = config.displayName || config.name;
           const role = config.identity?.role || 'AI Agent';