@agenticmail/enterprise 0.5.324 → 0.5.325

package/src/engine/routes.ts

@@ -343,6 +343,124 @@ engine.get('/cluster/best-node', (c) => {
   const node = cluster.findBestNode(caps);
   return node ? c.json(node) : c.json({ error: 'No suitable node available' }, 404);
 });
+engine.post('/cluster/test-connection', async (c) => {
+  const { host, port } = await c.req.json();
+  if (!host) return c.json({ error: 'host required' }, 400);
+  const p = port || 3101;
+  const start = Date.now();
+  try {
+    const ctrl = new AbortController();
+    const timeout = setTimeout(() => ctrl.abort(), 5000);
+    const res = await fetch(`http://${host}:${p}/health`, { signal: ctrl.signal }).catch(() => null);
+    clearTimeout(timeout);
+    if (res && res.ok) {
+      const data = await res.json().catch(() => ({}));
+      return c.json({ success: true, latencyMs: Date.now() - start, version: data.version, agentId: data.agentId });
+    }
+    // Try the enterprise status endpoint as fallback
+    const ctrl2 = new AbortController();
+    const timeout2 = setTimeout(() => ctrl2.abort(), 5000);
+    const res2 = await fetch(`http://${host}:${p}/api/status`, { signal: ctrl2.signal }).catch(() => null);
+    clearTimeout(timeout2);
+    if (res2 && res2.ok) {
+      return c.json({ success: true, latencyMs: Date.now() - start, version: 'enterprise' });
+    }
+    return c.json({ success: false, error: 'No response from ' + host + ':' + p, latencyMs: Date.now() - start });
+  } catch (e: any) {
+    return c.json({ success: false, error: e.message || 'Connection failed', latencyMs: Date.now() - start });
+  }
+});
+
+engine.post('/cluster/deploy-via-ssh', async (c) => {
+  const body = await c.req.json();
+  if (!body.host) return c.json({ error: 'host required' }, 400);
+  // Use the deployment engine's SSH infrastructure
+  try {
+    const dbUrl = process.env.DATABASE_URL || '';
+    const enterpriseUrl = process.env.ENTERPRISE_URL || `http://${body.host}:${body.port || 3101}`;
+    const nodeId = body.name?.toLowerCase().replace(/[^a-z0-9-]/g, '-') || 'worker-' + body.host.replace(/\./g, '-');
+
+    // Build remote setup script
+    const script = [
+      '#!/bin/bash',
+      'set -e',
+      'export NVM_DIR="$HOME/.nvm"',
+      '[ -s "$NVM_DIR/nvm.sh" ] && . "$NVM_DIR/nvm.sh"',
+      '',
+      '# Install Node.js if not present',
+      'if ! command -v node &> /dev/null; then',
+      '  if command -v apt-get &> /dev/null; then',
+      '    curl -fsSL https://deb.nodesource.com/setup_20.x | sudo -E bash -',
+      '    sudo apt-get install -y nodejs',
+      '  elif command -v brew &> /dev/null; then',
+      '    brew install node',
+      '  fi',
+      'fi',
+      '',
+      '# Install PM2 and AgenticMail',
+      'npm install -g pm2 @agenticmail/enterprise',
+      '',
+      '# Write env file',
+      'mkdir -p ~/.agenticmail',
+      `cat > ~/.agenticmail/worker.env << 'ENVEOF'`,
+      `ENTERPRISE_URL=${enterpriseUrl}`,
+      `WORKER_NODE_ID=${nodeId}`,
+      `WORKER_NAME="${body.name || nodeId}"`,
+      `DATABASE_URL=${dbUrl}`,
+      `PORT=${body.port || 3101}`,
+      'LOG_LEVEL=warn',
+      'ENVEOF',
+      '',
+      '# Start agents via PM2',
+      ...(body.agentIds || []).map((id: string, i: number) =>
+        `pm2 start "$(which agenticmail-enterprise || echo npx @agenticmail/enterprise) agent --id ${id}" --name "agent-${i}" --env ~/.agenticmail/worker.env`
+      ),
+      'pm2 save',
+      'echo "DEPLOY_SUCCESS"',
+    ].join('\n');
+
+    const { execSync } = await import('child_process');
+    const sshTarget = `${body.user || 'root'}@${body.host}`;
+    const keyOpt = body.privateKey ? `-i /tmp/_am_ssh_key_${Date.now()}` : '';
+
+    if (body.privateKey) {
+      const { writeFileSync, chmodSync } = await import('fs');
+      const keyPath = `/tmp/_am_ssh_key_${Date.now()}`;
+      writeFileSync(keyPath, body.privateKey, { mode: 0o600 });
+    }
+
+    const scriptB64 = Buffer.from(script).toString('base64');
+    const sshCmd = `ssh -o StrictHostKeyChecking=no -o ConnectTimeout=10 ${keyOpt} ${sshTarget} "echo '${scriptB64}' | base64 -d | bash"`;
+
+    // Run async — don't block the request
+    const { exec } = await import('child_process');
+    exec(sshCmd, { timeout: 120_000 }, (err, stdout, stderr) => {
+      if (err) {
+        console.warn(`[cluster] SSH deploy to ${body.host} failed:`, err.message);
+      } else if (stdout.includes('DEPLOY_SUCCESS')) {
+        console.log(`[cluster] SSH deploy to ${body.host} succeeded`);
+      }
+    });
+
+    return c.json({ message: 'Deployment started via SSH to ' + sshTarget + '. Check the Cluster page for the node to appear.', nodeId });
+  } catch (e: any) {
+    return c.json({ error: 'SSH deploy failed: ' + e.message }, 500);
+  }
+});
+
+engine.post('/cluster/nodes/:nodeId/restart', async (c) => {
+  const node = cluster.getNode(c.req.param('nodeId'));
+  if (!node) return c.json({ error: 'Node not found' }, 404);
+  try {
+    const ctrl = new AbortController();
+    setTimeout(() => ctrl.abort(), 10000);
+    await fetch(`${node.url}/restart`, { method: 'POST', signal: ctrl.signal }).catch(() => {});
+    return c.json({ ok: true, message: 'Restart signal sent to ' + node.name });
+  } catch (e: any) {
+    return c.json({ error: e.message }, 500);
+  }
+});
+
 engine.get('/cluster/stream', (c) => {
   const stream = new ReadableStream({
     start(controller) {

package/src/engine/NOTE.MD

@@ -1,52 +0,0 @@
-All done. Here's what I built:                                                                                                                  
-                                                                                                                                                 
- ### 1. Setup Wizard — Reverted (no LLM step)                                                                                                    
-                                                                                                                                                 
- Reverted back to original. Instead, SDKs auto-install during bootstrap — when an admin creates the first account, the server installs           
- @anthropic-ai/sdk, openai, and elevenlabs in the background.                                                                                    
-                                                                                                                                                 
- ### 2. Anthropic Token + API Key Support                                                                                                        
-                                                                                                                                                 
- The LLM client now supports two auth modes:                                                                                                     
-                                                                                                                                                 
- - api-key (default): Standard x-api-key header — for Anthropic API keys (sk-ant-...)                                                            
- - token: Authorization: Bearer header — for Anthropic Max subscription tokens, OAuth tokens, and proxy tokens (like OpenClaw uses)              
-                                                                                                                                                 
- This flows through: ModelConfig.authMode → AgentConfig → agent-loop.ts → callLLM() → callAnthropic() → Anthropic SDK's authToken parameter.     
-                                                                                                                                                 
- You can also set a custom baseUrl to point to any proxy endpoint.                                                                               
-                                                                                                                                                 
- ### 3. Meeting Voice (ElevenLabs + BlackHole)                                                                                                   
-                                                                                                                                                 
- Three new tools when meetings is enabled:                                                                                                       
-                                                                                                                                                 
- - meeting_speak — Converts text to speech via ElevenLabs, plays through BlackHole virtual mic. Meeting participants hear the agent speak.       
- - meeting_audio_setup — Checks if BlackHole, sox, and ElevenLabs are configured.                                                                
- - meeting_voices — Lists available voices (13 built-in + custom from ElevenLabs account).                                                       
-                                                                                                                                                 
- Architecture (works on any enterprise deployment):                                                                                              
-                                                                                                                                                 
- ```                                                                                                                                             
-   Agent LLM → "meeting_speak" tool → ElevenLabs API → MP3 file                                                                                  
-     → sox plays to BlackHole virtual device                                                                                                     
-     → Browser picks up BlackHole as microphone                                                                                                  
-     → Meeting participants hear the agent                                                                                                       
- ```                                                                                                                                             
-                                                                                                                                                 
- To enable on Mac Mini, you need to run:                                                                                                         
-                                                                                                                                                 
- ```bash                                                                                                                                         
-   brew install blackhole-2ch   # Virtual audio driver (needs sudo)                                                                              
-   brew install sox              # Audio routing to BlackHole                                                                                    
- ```                                                                                                                                             
-                                                                                                                                                 
- Then set ELEVENLABS_API_KEY in .env.fola.                                                                                                       
-                                                                                                                                                 
- ### 4. PM2 Fix                                                                                                                                  
-                                                                                                                                                 
- Ran pm2 save after stopping Fola — this persists the stopped state to the PM2 dump file. The dashboard's stop button only updates DB state but  
- doesn't call pm2 stop. That's a separate fix needed in the deployer (the local stop handler is a no-op).                                        
- connected | idle                 
-
-
-