@agenticmail/enterprise 0.5.103 → 0.5.105

package/dist/runtime-IPMNXLXU.js

@@ -0,0 +1,49 @@
+import {
+  AgentRuntime,
+  EmailChannel,
+  FollowUpScheduler,
+  SessionManager,
+  SubAgentManager,
+  ToolRegistry,
+  callLLM,
+  createAgentRuntime,
+  createNoopHooks,
+  createRuntimeHooks,
+  estimateMessageTokens,
+  estimateTokens,
+  executeTool,
+  runAgentLoop,
+  toolsToDefinitions
+} from "./chunk-SFLOH6XF.js";
+import "./chunk-TYW5XTOW.js";
+import "./chunk-AQH4DFYV.js";
+import {
+  PROVIDER_REGISTRY,
+  listAllProviders,
+  resolveApiKeyForProvider,
+  resolveProvider
+} from "./chunk-67KZYSLU.js";
+import "./chunk-JLSQOQ5L.js";
+import "./chunk-NRF3YRF7.js";
+import "./chunk-KFQGP6VL.js";
+export {
+  AgentRuntime,
+  EmailChannel,
+  FollowUpScheduler,
+  PROVIDER_REGISTRY,
+  SessionManager,
+  SubAgentManager,
+  ToolRegistry,
+  callLLM,
+  createAgentRuntime,
+  createNoopHooks,
+  createRuntimeHooks,
+  estimateMessageTokens,
+  estimateTokens,
+  executeTool,
+  listAllProviders,
+  resolveApiKeyForProvider,
+  resolveProvider,
+  runAgentLoop,
+  toolsToDefinitions
+};

package/dist/runtime-PT77GRSQ.js

@@ -0,0 +1,49 @@
+import {
+  AgentRuntime,
+  EmailChannel,
+  FollowUpScheduler,
+  SessionManager,
+  SubAgentManager,
+  ToolRegistry,
+  callLLM,
+  createAgentRuntime,
+  createNoopHooks,
+  createRuntimeHooks,
+  estimateMessageTokens,
+  estimateTokens,
+  executeTool,
+  runAgentLoop,
+  toolsToDefinitions
+} from "./chunk-EVLC3NXM.js";
+import "./chunk-NRF3YRF7.js";
+import "./chunk-TYW5XTOW.js";
+import "./chunk-AQH4DFYV.js";
+import "./chunk-JLSQOQ5L.js";
+import {
+  PROVIDER_REGISTRY,
+  listAllProviders,
+  resolveApiKeyForProvider,
+  resolveProvider
+} from "./chunk-67KZYSLU.js";
+import "./chunk-KFQGP6VL.js";
+export {
+  AgentRuntime,
+  EmailChannel,
+  FollowUpScheduler,
+  PROVIDER_REGISTRY,
+  SessionManager,
+  SubAgentManager,
+  ToolRegistry,
+  callLLM,
+  createAgentRuntime,
+  createNoopHooks,
+  createRuntimeHooks,
+  estimateMessageTokens,
+  estimateTokens,
+  executeTool,
+  listAllProviders,
+  resolveApiKeyForProvider,
+  resolveProvider,
+  runAgentLoop,
+  toolsToDefinitions
+};

package/dist/server-4MPCGSSO.js

@@ -0,0 +1,12 @@
+import {
+  createServer
+} from "./chunk-SNZUZYHO.js";
+import "./chunk-3SMTCIR4.js";
+import "./chunk-JLSQOQ5L.js";
+import "./chunk-RO537U6H.js";
+import "./chunk-DRXMYYKN.js";
+import "./chunk-67KZYSLU.js";
+import "./chunk-KFQGP6VL.js";
+export {
+  createServer
+};

package/dist/server-JO3SS5N7.js

@@ -0,0 +1,12 @@
+import {
+  createServer
+} from "./chunk-7V7ZZJAG.js";
+import "./chunk-3SMTCIR4.js";
+import "./chunk-RO537U6H.js";
+import "./chunk-DRXMYYKN.js";
+import "./chunk-67KZYSLU.js";
+import "./chunk-JLSQOQ5L.js";
+import "./chunk-KFQGP6VL.js";
+export {
+  createServer
+};

package/dist/setup-EY7EH7IU.js

@@ -0,0 +1,20 @@
+import {
+  promptCompanyInfo,
+  promptDatabase,
+  promptDeployment,
+  promptDomain,
+  promptRegistration,
+  provision,
+  runSetupWizard
+} from "./chunk-ZFO44EVP.js";
+import "./chunk-QDXUZP7Y.js";
+import "./chunk-KFQGP6VL.js";
+export {
+  promptCompanyInfo,
+  promptDatabase,
+  promptDeployment,
+  promptDomain,
+  promptRegistration,
+  provision,
+  runSetupWizard
+};

package/dist/setup-WDWEO76A.js

@@ -0,0 +1,20 @@
+import {
+  promptCompanyInfo,
+  promptDatabase,
+  promptDeployment,
+  promptDomain,
+  promptRegistration,
+  provision,
+  runSetupWizard
+} from "./chunk-I7MWMKQX.js";
+import "./chunk-QDXUZP7Y.js";
+import "./chunk-KFQGP6VL.js";
+export {
+  promptCompanyInfo,
+  promptDatabase,
+  promptDeployment,
+  promptDomain,
+  promptRegistration,
+  provision,
+  runSetupWizard
+};

package/package.json

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

package/src/cli-agent.ts

@@ -0,0 +1,201 @@
+/**
+ * `npx @agenticmail/enterprise agent`
+ *
+ * Standalone agent runtime — runs a single agent as its own process.
+ * Designed for Fly.io / Docker deployments where each agent gets its own machine.
+ *
+ * Required env vars:
+ *   DATABASE_URL          — Postgres connection string (shared enterprise DB)
+ *   JWT_SECRET            — JWT signing secret (must match enterprise server)
+ *   AGENTICMAIL_AGENT_ID  — Agent UUID from the enterprise DB
+ *
+ * Optional env vars:
+ *   PORT                  — Health check HTTP port (default: 3000)
+ *   AGENTICMAIL_MODEL     — Override model (e.g. "anthropic/claude-sonnet-4-20250514")
+ *   AGENTICMAIL_THINKING  — Thinking level (e.g. "low", "medium", "high")
+ *   ANTHROPIC_API_KEY     — Anthropic API key
+ *   OPENAI_API_KEY        — OpenAI API key
+ *   XAI_API_KEY           — xAI API key
+ */
+
+import { Hono } from 'hono';
+import { serve } from '@hono/node-server';
+
+export async function runAgent(_args: string[]) {
+  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('🤖 AgenticMail Agent Runtime');
+  console.log(`   Agent ID: ${AGENT_ID}`);
+  console.log('   Connecting to database...');
+
+  // 1. Connect to shared enterprise DB
+  const { createAdapter } = await import('./db/factory.js');
+  const db = await createAdapter({
+    type: DATABASE_URL.startsWith('postgres') ? 'postgres' : 'sqlite',
+    connectionString: DATABASE_URL,
+  });
+  await db.migrate();
+
+  // 2. Initialize engine DB
+  const { EngineDatabase } = await import('./engine/db-adapter.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: Record<string, string> = {
+    sqlite: 'sqlite', postgres: 'postgres', supabase: 'postgres',
+    neon: 'postgres', cockroachdb: 'postgres',
+  };
+  const engineDialect = (dialectMap[adapterDialect] || adapterDialect) as any;
+  const engineDb = new EngineDatabase(engineDbInterface, engineDialect);
+  await engineDb.migrate();
+
+  // 3. Load agent config from DB
+  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}`);
+
+  // 4. Initialize lifecycle (manages agent state, config decryption)
+  const { AgentLifecycle } = await import('./engine/lifecycle.js');
+  const lifecycle = new AgentLifecycle(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}`);
+
+  // 5. Initialize memory manager
+  let memoryManager: any;
+  try {
+    const { AgentMemoryManager } = await import('./engine/agent-memory.js');
+    memoryManager = new AgentMemoryManager(engineDb);
+    console.log('   Memory: DB-backed');
+  } catch { console.log('   Memory: file-based fallback'); }
+
+  // 6. Load provider API keys from DB settings
+  try {
+    const settings = await db.getSettings();
+    const keys = settings?.modelPricingConfig?.providerApiKeys;
+    if (keys && typeof keys === 'object') {
+      const { PROVIDER_REGISTRY } = await import('./runtime/providers.js');
+      for (const [providerId, apiKey] of Object.entries(keys)) {
+        const envVar = (PROVIDER_REGISTRY as any)[providerId]?.envKey;
+        if (envVar && apiKey && !process.env[envVar]) {
+          process.env[envVar] = apiKey as string;
+          console.log(`   🔑 Loaded API key for ${providerId}`);
+        }
+      }
+    }
+  } catch {}
+
+  // 7. Create agent runtime
+  const { createAgentRuntime } = await import('./runtime/index.js');
+
+  const getEmailConfig = (agentId: string) => {
+    const m = lifecycle.getAgent(agentId);
+    return m?.config?.emailConfig || null;
+  };
+  const onTokenRefresh = (agentId: string, tokens: any) => {
+    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(() => {});
+    }
+  };
+
+  // Parse model from env or agent config
+  let defaultModel: any;
+  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();
+
+  // 8. Start health check HTTP server
+  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 }));
+
+  // Mount runtime API if available
+  if (runtimeApp) {
+    app.route('/api/runtime', runtimeApp);
+  }
+
+  serve({ fetch: app.fetch, port: PORT }, (info) => {
+    console.log(`\n✅ Agent runtime started`);
+    console.log(`   Health: http://localhost:${info.port}/health`);
+    console.log(`   Runtime: http://localhost:${info.port}/api/runtime`);
+    console.log('');
+  });
+
+  // Graceful shutdown
+  const shutdown = () => {
+    console.log('\n⏳ Shutting down agent...');
+    runtime.stop().then(() => db.disconnect()).then(() => {
+      console.log('✅ Agent shutdown complete');
+      process.exit(0);
+    });
+    setTimeout(() => process.exit(1), 10_000).unref();
+  };
+  process.on('SIGINT', shutdown);
+  process.on('SIGTERM', shutdown);
+
+  // 9. Update agent state to 'running'
+  try {
+    await engineDb.query(
+      `UPDATE managed_agents SET state = 'running', updated_at = $1 WHERE id = $2`,
+      [new Date().toISOString(), AGENT_ID]
+    );
+    console.log('   State: running');
+  } catch {}
+}

package/src/cli-serve.ts

@@ -0,0 +1,38 @@
+/**
+ * `npx @agenticmail/enterprise serve`
+ *
+ * Starts the enterprise server headlessly (no interactive wizard).
+ * Reads configuration from environment variables:
+ *   DATABASE_URL  — Postgres/SQLite connection string (required)
+ *   JWT_SECRET    — JWT signing secret (required)
+ *   PORT          — HTTP port (default: 8080)
+ */
+
+export async function runServe(_args: string[]) {
+  const DATABASE_URL = process.env.DATABASE_URL;
+  const JWT_SECRET = process.env.JWT_SECRET;
+  const PORT = parseInt(process.env.PORT || '8080', 10);
+
+  if (!DATABASE_URL) { console.error('ERROR: DATABASE_URL environment variable is required'); process.exit(1); }
+  if (!JWT_SECRET) { console.error('ERROR: JWT_SECRET environment variable is required'); process.exit(1); }
+
+  const { createAdapter } = await import('./db/factory.js');
+  const { createServer } = await import('./server.js');
+
+  const db = await createAdapter({
+    type: DATABASE_URL.startsWith('postgres') ? 'postgres' : 'sqlite',
+    connectionString: DATABASE_URL,
+  });
+
+  await db.migrate();
+
+  const server = createServer({
+    port: PORT,
+    db,
+    jwtSecret: JWT_SECRET,
+    corsOrigins: ['*'],
+  });
+
+  await server.start();
+  console.log(`AgenticMail Enterprise server running on :${PORT}`);
+}

package/src/cli.ts

@@ -72,6 +72,14 @@ Skill Development:
 `);
     break;
 
+  case 'serve':
+    import('./cli-serve.js').then(m => m.runServe(args.slice(1))).catch(fatal);
+    break;
+
+  case 'agent':
+    import('./cli-agent.js').then(m => m.runAgent(args.slice(1))).catch(fatal);
+    break;
+
   case 'setup':
   default:
     import('./setup/index.js').then(m => m.runSetupWizard()).catch(fatal);

package/src/engine/deployer.ts

@@ -451,23 +451,19 @@ export class DeploymentEngine {
       }
     }
 
-    // 2. Generate workspace files and encode as base64 init script
+    // 2. Build environment variables — agent reads config from shared DB
     emit('configure', 'started', 'Preparing agent configuration...');
-    const workspace = this.configGen.generateWorkspace(config);
-    const initCommands = Object.entries(workspace).map(([file, content]) => {
-      const b64 = Buffer.from(content).toString('base64');
-      return `echo "${b64}" | base64 -d > /workspace/${file}`;
-    }).join(' && ');
-
-    // Build environment variables for the agent
     const env: Record<string, string> = {
       NODE_ENV: 'production',
-      AGENTICMAIL_MODEL: `${config.model.provider}/${config.model.modelId}`,
       AGENTICMAIL_AGENT_ID: config.id,
       AGENTICMAIL_AGENT_NAME: config.displayName || config.name,
+      AGENTICMAIL_MODEL: `${config.model?.provider || 'anthropic'}/${config.model?.modelId || 'claude-sonnet-4-20250514'}`,
       PORT: '3000',
     };
-    if (config.model.thinkingLevel) env.AGENTICMAIL_THINKING = config.model.thinkingLevel;
+    if (config.model?.thinkingLevel) env.AGENTICMAIL_THINKING = config.model.thinkingLevel;
+    // Pass shared DB credentials so agent connects to the same enterprise DB
+    if (process.env.DATABASE_URL) env.DATABASE_URL = process.env.DATABASE_URL;
+    if (process.env.JWT_SECRET) env.JWT_SECRET = process.env.JWT_SECRET;
     emit('configure', 'completed', 'Configuration ready');
 
     // 3. Check for existing machines — update if found, create if not
@@ -478,8 +474,8 @@ export class DeploymentEngine {
       env,
       services: [{
         ports: [
-          { port: 443, handlers: ['tls', 'http'], force_https: true },
-          { port: 80, handlers: ['http'] },
+          { port: 443, handlers: ['tls', 'http'] },
+          { port: 80, handlers: ['http'], force_https: true },
         ],
         protocol: 'tcp',
         internal_port: 3000,
@@ -490,7 +486,7 @@ export class DeploymentEngine {
         memory_mb: size.includes('2x') ? 1024 : 512,
       },
       init: {
-        cmd: ['sh', '-c', `mkdir -p /workspace && ${initCommands || 'true'} && npx @agenticmail/enterprise start`],
+        cmd: ['sh', '-c', 'npx --yes @agenticmail/enterprise agent'],
       },
       auto_destroy: false,
       restart: { policy: 'always' },