Skip to content

Self-improving AI Employees for everyone

Add session persistence and standardize AI model outputs

trohitg85f9a95b1790
diff --git a/client/src/components/parameterPanel/InputSection.tsx b/client/src/components/parameterPanel/InputSection.tsx
index fe8f84cc..b50a5485 100644
--- a/client/src/components/parameterPanel/InputSection.tsx
+++ b/client/src/components/parameterPanel/InputSection.tsx
@@ -152,7 +152,7 @@ const InputSection: React.FC<InputSectionProps> = ({ nodeId, visible = true }) =
} else {
const sampleSchemas: Record<string, Record<string, any>> = {
location: { latitude: 'number', longitude: 'number', accuracy: 'number', provider: 'string', altitude: 'number' },
- ai: { response: 'string', model: 'string', usage: { tokens: 'number' } },
+ ai: { response: 'string', model: 'string', provider: 'string', finish_reason: 'string', timestamp: 'string' },
file: { fileName: 'string', fileSize: 'number' },
whatsapp: {
message_id: 'string',
@@ -309,7 +309,8 @@ const InputSection: React.FC<InputSectionProps> = ({ nodeId, visible = true }) =
// Node type detection
const isMemory = nodeType === 'simpleMemory';
- const isAI = !isMemory && (nodeType.includes('ai') || nodeType.includes('chat'));
+ const nodeTypeLower = nodeType.toLowerCase();
+ const isAI = !isMemory && (nodeTypeLower.includes('chatmodel') || nodeTypeLower.includes('aiagent'));
const isFile = nodeType.includes('file');
const isWhatsApp = nodeType.includes('whatsapp') || nodeType.includes('Whatsapp');
const isWebhook = nodeType === 'webhookTrigger';
diff --git a/client/src/nodeDefinitions/whatsappNodes.ts b/client/src/nodeDefinitions/whatsappNodes.ts
index 5c7d3053..111c1157 100644
--- a/client/src/nodeDefinitions/whatsappNodes.ts
+++ b/client/src/nodeDefinitions/whatsappNodes.ts
@@ -719,6 +719,29 @@ export const whatsappNodes: Record<string, INodeTypeDescription> = {
description: 'Filter by message type'
},
+ // ===== RESULT MODE =====
+ {
+ displayName: 'Result Mode',
+ name: 'resultMode',
+ type: 'options',
+ options: [
+ { name: 'Multiple Messages', value: 'multiple' },
+ { name: 'Single Message by Position', value: 'single' }
+ ],
+ default: 'multiple',
+ description: 'Return multiple messages or a single message at specific position'
+ },
+ {
+ displayName: 'Message Position',
+ name: 'position',
+ type: 'number',
+ default: 1,
+ description: 'Position: positive from newest (1=most recent), negative from oldest (-1=oldest)',
+ displayOptions: {
+ show: { resultMode: ['single'] }
+ }
+ },
+
// ===== PAGINATION =====
{
displayName: 'Limit',
@@ -726,7 +749,10 @@ export const whatsappNodes: Record<string, INodeTypeDescription> = {
type: 'number',
default: 50,
typeOptions: { minValue: 1, maxValue: 500 },
- description: 'Maximum number of messages to retrieve (1-500)'
+ description: 'Maximum number of messages to retrieve (1-500)',
+ displayOptions: {
+ show: { resultMode: ['multiple'] }
+ }
},
{
displayName: 'Offset',
@@ -734,7 +760,10 @@ export const whatsappNodes: Record<string, INodeTypeDescription> = {
type: 'number',
default: 0,
typeOptions: { minValue: 0 },
- description: 'Number of messages to skip (for pagination)'
+ description: 'Number of messages to skip (for pagination)',
+ displayOptions: {
+ show: { resultMode: ['multiple'] }
+ }
}
],
methods: {
diff --git a/deploy.sh b/deploy.sh
index ba8c9169..1c878c4a 100644
--- a/deploy.sh
+++ b/deploy.sh
@@ -55,11 +55,19 @@ tar --exclude='node_modules' \
scp /tmp/machinaos-src.tar.gz "${GCP_HOST}:/tmp/${SERVICE_NAME}/"
-# Upload production .env (prefer .env.production, fallback to .env)
+# Upload production .env (prefer .env.production, fallback to .env, then create from template)
if [ -f "${LOCAL_DIR}/server/.env.production" ]; then
scp "${LOCAL_DIR}/server/.env.production" "${GCP_HOST}:/tmp/${SERVICE_NAME}/.env"
elif [ -f "${LOCAL_DIR}/server/.env" ]; then
scp "${LOCAL_DIR}/server/.env" "${GCP_HOST}:/tmp/${SERVICE_NAME}/.env"
+elif [ -f "${LOCAL_DIR}/.env.template" ]; then
+ echo "No .env found, creating from .env.template..."
+ scp "${LOCAL_DIR}/.env.template" "${GCP_HOST}:/tmp/${SERVICE_NAME}/.env"
+elif [ -f "${LOCAL_DIR}/server/.env.template" ]; then
+ echo "No .env found, creating from server/.env.template..."
+ scp "${LOCAL_DIR}/server/.env.template" "${GCP_HOST}:/tmp/${SERVICE_NAME}/.env"
+else
+ echo "Warning: No .env or .env.template found. Using docker-compose environment variables only."
fi
# Step 2: Build and deploy on remote
diff --git a/scripts/docker.js b/scripts/docker.js
index 2f1b07dd..c2ed8ed5 100644
--- a/scripts/docker.js
+++ b/scripts/docker.js
@@ -6,13 +6,36 @@
*/
import { spawn } from 'child_process';
-import { readFileSync, existsSync } from 'fs';
+import { readFileSync, existsSync, copyFileSync } from 'fs';
import { fileURLToPath } from 'url';
import { dirname, resolve } from 'path';
const __dirname = dirname(fileURLToPath(import.meta.url));
const ROOT = resolve(__dirname, '..');
+// Create .env from template if it doesn't exist
+function ensureEnvFile() {
+ const envPath = resolve(ROOT, '.env');
+ if (existsSync(envPath)) return true;
+
+ // Try root .env.template first, then server/.env.template
+ const templates = [
+ resolve(ROOT, '.env.template'),
+ resolve(ROOT, 'server', '.env.template')
+ ];
+
+ for (const templatePath of templates) {
+ if (existsSync(templatePath)) {
+ console.log(`[Docker] Creating .env from ${templatePath.replace(ROOT, '.')}`);
+ copyFileSync(templatePath, envPath);
+ return true;
+ }
+ }
+
+ console.warn('[Docker] Warning: No .env or .env.template found');
+ return false;
+}
+
// Read .env file and check REDIS_ENABLED
function isRedisEnabled() {
const envPath = resolve(ROOT, '.env');
@@ -35,6 +58,9 @@ if (!command) {
process.exit(1);
}
+// Ensure .env exists (create from template if needed)
+ensureEnvFile();
+
// Build docker-compose command
const composeArgs = [];
diff --git a/server/core/database.py b/server/core/database.py
index a9e72d00..20a28a7d 100644
--- a/server/core/database.py
+++ b/server/core/database.py
@@ -864,4 +864,64 @@ class Database:
except Exception as e:
logger.error("Failed to get all tool schemas", error=str(e))
- return []
\ No newline at end of file
+ return []
+
+ # ============================================================================
+ # Android Relay Session Persistence
+ # ============================================================================
+
+ async def save_android_relay_session(
+ self,
+ relay_url: str,
+ api_key: str,
+ device_id: str,
+ device_name: Optional[str] = None,
+ session_token: Optional[str] = None
+ ) -> bool:
+ """Save Android relay pairing session for auto-reconnect on server restart.
+
+ Args:
+ relay_url: WebSocket relay URL
+ api_key: API key for relay authentication
+ device_id: Paired Android device ID
+ device_name: Paired device name
+ session_token: Relay session token
+ """
+ import json
+ try:
+ session_data = json.dumps({
+ "relay_url": relay_url,
+ "api_key": api_key,
+ "device_id": device_id,
+ "device_name": device_name,
+ "session_token": session_token
+ })
+ # No TTL - session persists until explicitly cleared
+ return await self.set_cache_entry("android_relay_session", session_data)
+ except Exception as e:
+ logger.error("Failed to save Android relay session", error=str(e))
+ return False
+
+ async def get_android_relay_session(self) -> Optional[Dict[str, Any]]:
+ """Get stored Android relay session for auto-reconnect.
+
+ Returns:
+ Session data dict or None if not found
+ """
+ import json
+ try:
+ value = await self.get_cache_entry("android_relay_session")
+ if value:
+ return json.loads(value)
+ return None
+ except Exception as e:
+ logger.error("Failed to get Android relay session", error=str(e))
+ return None
+
+ async def clear_android_relay_session(self) -> bool:
+ """Clear stored Android relay session (on explicit disconnect)."""
+ try:
+ return await self.delete_cache_entry("android_relay_session")
+ except Exception as e:
+ logger.error("Failed to clear Android relay session", error=str(e))
+ return False
\ No newline at end of file
diff --git a/server/services/android/client.py b/server/services/android/client.py
index 4068ef70..dd7b2908 100644
--- a/server/services/android/client.py
+++ b/server/services/android/client.py
@@ -159,9 +159,15 @@ class RelayWebSocketClient:
logger.error("[Relay] Connection error", error=str(e), exc_info=True)
return False, f"Connection error: {str(e)}"
- async def disconnect(self):
- """Close connection and cleanup."""
- logger.info("[Relay] Disconnecting...")
+ async def disconnect(self, clear_stored_session: bool = True):
+ """Close connection and cleanup.
+
+ Args:
+ clear_stored_session: If True, clear stored pairing session from database.
+ Set to False when disconnecting due to connection drop
+ (will try to auto-reconnect later).
+ """
+ logger.info("[Relay] Disconnecting...", clear_stored_session=clear_stored_session)
self._running = False
# Cancel background tasks
@@ -191,11 +197,26 @@ class RelayWebSocketClient:
# Cancel pending RPC requests
self._rpc_tracker.cancel_all()
+ # Clear stored session if explicitly disconnecting
+ if clear_stored_session:
+ await self._clear_stored_session()
+
# Broadcast relay disconnection (fully disconnected from relay server)
await broadcast_relay_disconnected()
logger.info("[Relay] Disconnected")
+ async def _clear_stored_session(self):
+ """Clear stored pairing session from database."""
+ try:
+ from core.container import container
+ database = container.database()
+
+ await database.clear_android_relay_session()
+ logger.info("[Relay] Cleared stored pairing session")
+ except Exception as e:
+ logger.warning("[Relay] Failed to clear stored session", error=str(e))
+
def is_connected(self) -> bool:
"""Check if connected to relay server."""
return self.connected and self._running and self.ws is not None and not self.ws.closed
@@ -318,9 +339,29 @@ class RelayWebSocketClient:
await broadcast_connected(self.paired_device_id, self.paired_device_name)
+ # Persist pairing data for auto-reconnect on server restart
+ await self._save_pairing_session()
+
if self.on_pairing_connected:
await self.on_pairing_connected(params)
+ async def _save_pairing_session(self):
+ """Save pairing session to database for auto-reconnect."""
+ try:
+ from core.container import container
+ database = container.database()
+
+ await database.save_android_relay_session(
+ relay_url=self.base_url,
+ api_key=self.api_key,
+ device_id=self.paired_device_id,
+ device_name=self.paired_device_name,
+ session_token=self.session_token
+ )
+ logger.info("[Relay] Pairing session saved for auto-reconnect")
+ except Exception as e:
+ logger.warning("[Relay] Failed to save pairing session", error=str(e))
+
async def _handle_pairing_disconnected(self, params: dict):
"""Handle pairing.disconnected event.
diff --git a/server/services/android/manager.py b/server/services/android/manager.py
index 5d1b585e..6dbd197d 100644
--- a/server/services/android/manager.py
+++ b/server/services/android/manager.py
@@ -51,12 +51,17 @@ async def get_relay_client(base_url: str, api_key: str) -> tuple[Optional[RelayW
return None, error
-async def close_relay_client():
- """Close global relay client."""
+async def close_relay_client(clear_stored_session: bool = True):
+ """Close global relay client.
+
+ Args:
+ clear_stored_session: If True, clear stored pairing session from database.
+ This prevents auto-reconnect on next client connect.
+ """
global _relay_client
if _relay_client:
- logger.info("[Manager] Closing connection")
- await _relay_client.disconnect()
+ logger.info("[Manager] Closing connection", clear_stored_session=clear_stored_session)
+ await _relay_client.disconnect(clear_stored_session=clear_stored_session)
_relay_client = None
diff --git a/server/services/handlers/whatsapp.py b/server/services/handlers/whatsapp.py
index 9d802f60..012551f1 100644
--- a/server/services/handlers/whatsapp.py
+++ b/server/services/handlers/whatsapp.py
@@ -226,9 +226,51 @@ async def handle_whatsapp_chat_history(
message_filter = parameters.get('messageFilter', 'all')
rpc_params['text_only'] = message_filter == 'text_only'
- # Pagination
- rpc_params['limit'] = parameters.get('limit', 50)
- rpc_params['offset'] = parameters.get('offset', 0)
+ # Result mode and pagination
+ result_mode = parameters.get('resultMode', 'multiple')
+ position = parameters.get('position', 1)
+
+ if result_mode == 'single':
+ # Single message by position mode
+ if position > 0:
+ # Positive: from newest (1=most recent)
+ rpc_params['limit'] = 1
+ rpc_params['offset'] = position - 1
+ else:
+ # Negative: from oldest (-1=oldest)
+ # First, get total count with limit=1 to minimize data transfer
+ rpc_params['limit'] = 1
+ rpc_params['offset'] = 0
+ count_data = await whatsapp_chat_history_handler(rpc_params)
+ total = count_data.get('total', 0)
+
+ if total == 0:
+ return {
+ "success": True,
+ "node_id": node_id,
+ "node_type": "whatsappChatHistory",
+ "result": {
+ "messages": [],
+ "total": 0,
+ "has_more": False,
+ "count": 0,
+ "chat_type": chat_type,
+ "timestamp": datetime.now().isoformat()
+ },
+ "execution_time": time.time() - start_time,
+ "timestamp": datetime.now().isoformat()
+ }
+
+ # Calculate offset from the end: -1 = last (oldest in desc order = total-1)
+ # Since messages are ordered DESC (newest first), -1 means oldest = offset total-1
+ offset = total + position # e.g., total=100, pos=-1 -> offset=99
+ if offset < 0:
+ offset = 0
+ rpc_params['offset'] = offset
+ else:
+ # Multiple messages mode - use standard pagination
+ rpc_params['limit'] = parameters.get('limit', 50)
+ rpc_params['offset'] = parameters.get('offset', 0)
# Call WhatsApp Go RPC service
data = await whatsapp_chat_history_handler(rpc_params)
@@ -241,6 +283,11 @@ async def handle_whatsapp_chat_history(
total = data.get('total', 0)
has_more = data.get('has_more', False)
+ # Add index to each message (1-based, from offset)
+ base_offset = rpc_params.get('offset', 0)
+ for i, msg in enumerate(messages):
+ msg['index'] = base_offset + i + 1
+
return {
"success": True,
"node_id": node_id,
diff --git a/server/services/status_broadcaster.py b/server/services/status_broadcaster.py
index 04d5a571..d916f202 100644
--- a/server/services/status_broadcaster.py
+++ b/server/services/status_broadcaster.py
@@ -69,6 +69,13 @@ class StatusBroadcaster:
self._connections.add(websocket)
logger.info(f"[StatusBroadcaster] Client connected. Total: {len(self._connections)}")
+ # Fetch fresh WhatsApp status before sending initial_status
+ # This ensures client sees actual connection state (especially after auto-connect)
+ await self._refresh_whatsapp_status()
+
+ # Auto-reconnect Android relay if there's a stored session
+ await self._auto_reconnect_android_relay()
+
# Send current full status immediately
try:
await websocket.send_json({
@@ -194,6 +201,106 @@ class StatusBroadcaster:
# WhatsApp Status Updates
# =========================================================================
+ async def _refresh_whatsapp_status(self):
+ """Fetch fresh WhatsApp status from Go service and update cache.
+
+ Called on client connect to ensure initial_status has accurate data.
+ Silently fails if WhatsApp service is unavailable.
+ """
+ try:
+ from routers.whatsapp import get_client
+ import time
+
+ client = await get_client()
+ status_data = await client.call("status")
+
+ self._status["whatsapp"] = {
+ "connected": status_data.get("connected", False),
+ "has_session": status_data.get("has_session", False),
+ "running": status_data.get("running", False),
+ "pairing": status_data.get("pairing", False),
+ "device_id": status_data.get("device_id"),
+ "qr": None,
+ "timestamp": time.time()
+ }
+ logger.debug(f"[StatusBroadcaster] Refreshed WhatsApp status: connected={status_data.get('connected')}")
+ except Exception as e:
+ # Don't fail client connection if WhatsApp service is down
+ logger.debug(f"[StatusBroadcaster] Could not refresh WhatsApp status: {e}")
+
+ async def _auto_reconnect_android_relay(self):
+ """Auto-reconnect to Android relay if there's a stored pairing session.
+
+ Called on client connect to re-establish relay connection after server restart.
+ The stored session contains relay URL, API key, and paired device info.
+ """
+ try:
+ # Check if already connected
+ from services.android.manager import get_current_relay_client
+ existing = get_current_relay_client()
+ if existing and existing.is_connected():
+ # Already connected, just refresh status
+ self._status["android"] = {
+ "connected": True,
+ "paired": existing.is_paired(),
+ "device_id": existing.paired_device_id,
+ "device_name": existing.paired_device_name,
+ "connected_devices": list(existing.get_connected_devices()),
+ "connection_type": "relay",
+ "qr_data": existing.qr_data,
+ "session_token": existing.session_token
+ }
+ logger.debug("[StatusBroadcaster] Android relay already connected")
+ return
+
+ # Check for stored session
+ from core.container import container
+ database = container.database()
+
+ session = await database.get_android_relay_session()
+ if not session:
+ logger.debug("[StatusBroadcaster] No stored Android relay session")
+ return
+
+ relay_url = session.get("relay_url")
+ api_key = session.get("api_key")
+ device_id = session.get("device_id")
+ device_name = session.get("device_name")
+
+ if not relay_url or not api_key:
+ logger.debug("[StatusBroadcaster] Stored session missing relay URL or API key")
+ return
+
+ logger.info(f"[StatusBroadcaster] Auto-reconnecting to Android relay...",
+ relay_url=relay_url, device_id=device_id)
+
+ # Attempt to reconnect
+ from services.android.manager import get_relay_client
+ client, error = await get_relay_client(relay_url, api_key)
+
+ if client and client.is_connected():
+ logger.info("[StatusBroadcaster] Android relay reconnected successfully")
+ # Update status - connected to relay but need to check if still paired
+ # The relay server creates a new session on each connect, so pairing is lost
+ # Update the cached status to reflect the current state
+ self._status["android"] = {
+ "connected": True,
+ "paired": client.is_paired(),
+ "device_id": client.paired_device_id,
+ "device_name": client.paired_device_name,
+ "connected_devices": list(client.get_connected_devices()),
+ "connection_type": "relay",
+ "qr_data": client.qr_data,
+ "session_token": client.session_token
+ }
+ else:
+ logger.warning(f"[StatusBroadcaster] Failed to reconnect Android relay: {error}")
+ # Clear the stored session since reconnect failed
+ await database.clear_android_relay_session()
+
+ except Exception as e:
+ logger.debug(f"[StatusBroadcaster] Could not auto-reconnect Android relay: {e}")
+
async def update_whatsapp_status(
self,
connected: bool,
diff --git a/server/whatsapp-rpc/src/go/cmd/server/main.go b/server/whatsapp-rpc/src/go/cmd/server/main.go
index c90247d0..87176ea0 100644
--- a/server/whatsapp-rpc/src/go/cmd/server/main.go
+++ b/server/whatsapp-rpc/src/go/cmd/server/main.go
@@ -42,6 +42,16 @@ func main() {
logger.Fatalf("Failed to initialize WhatsApp service: %v", err)
}
+ // Auto-start if there's an existing session (no need to press Start button)
+ if whatsappService.HasExistingSession() {
+ logger.Info("Existing session found, auto-connecting...")
+ if err := whatsappService.Start(); err != nil {
+ logger.Warnf("Auto-start failed: %v (user can manually start)", err)
+ }
+ } else {
+ logger.Info("No existing session, waiting for user to start pairing")
+ }
+
// Create and start server (WebSocket RPC only)
srv := server.New(whatsappService, logger)
router := srv.SetupRoutes()
diff --git a/server/whatsapp-rpc/src/go/whatsapp/history.go b/server/whatsapp-rpc/src/go/whatsapp/history.go
index 19eae8db..52ce648c 100644
--- a/server/whatsapp-rpc/src/go/whatsapp/history.go
+++ b/server/whatsapp-rpc/src/go/whatsapp/history.go
@@ -152,6 +152,12 @@ func (h *HistoryStore) Close() error {
return nil
}
+// ClearHistory deletes all messages from the history store
+func (h *HistoryStore) ClearHistory() error {
+ _, err := h.db.Exec("DELETE FROM message_history")
+ return err
+}
+
func boolToInt(b bool) int {
if b {
return 1
diff --git a/server/whatsapp-rpc/src/go/whatsapp/service.go b/server/whatsapp-rpc/src/go/whatsapp/service.go
index 37c09982..401dda7c 100644
--- a/server/whatsapp-rpc/src/go/whatsapp/service.go
+++ b/server/whatsapp-rpc/src/go/whatsapp/service.go
@@ -123,6 +123,17 @@ func NewService(dbConfig config.DatabaseConfig, logger *logrus.Logger) (*Service
return service, nil
}
+// HasExistingSession returns true if there's a stored session that can be used to auto-connect
+func (s *Service) HasExistingSession() bool {
+ hasClient := s.client != nil
+ hasStore := hasClient && s.client.Store != nil
+ hasID := hasStore && s.client.Store.ID != nil
+
+ s.logger.Infof("HasExistingSession check: client=%v, store=%v, id=%v", hasClient, hasStore, hasID)
+
+ return hasID
+}
+
func (s *Service) safeEventSend(event Event) {
if s.shutdown {
return
@@ -1916,23 +1927,20 @@ func (s *Service) Reset() error {
}
}
+ // Clear message history (belongs to old instance)
+ if s.historyStore != nil {
+ s.logger.Info("Clearing message history...")
+ if err := s.historyStore.ClearHistory(); err != nil {
+ s.logger.Warnf("Failed to clear history: %v", err)
+ }
+ }
+
// Clear client reference to allow GC and release DB locks
s.client = nil
s.container = nil
// Give time for database to release locks
- time.Sleep(2 * time.Second)
-
- // Delete database files
- dbFiles := []string{s.dbPath, s.dbPath + "-wal", s.dbPath + "-shm"}
- for _, file := range dbFiles {
- if _, err := os.Stat(file); err == nil {
- s.logger.Infof("Deleting: %s", file)
- if err := os.Remove(file); err != nil {
- s.logger.Warnf("Failed to delete %s: %v", file, err)
- }
- }
- }
+ time.Sleep(500 * time.Millisecond)
// Reinitialize client with fresh database
if err := s.reinitClient(); err != nil {