@xagent-ai/cli 1.3.7 → 1.4.1

package/dist/session.js

@@ -1,5 +1,4 @@
 import readline from 'readline';
-import chalk from 'chalk';
 import https from 'https';
 import axios from 'axios';
 import crypto from 'crypto';
@@ -67,9 +66,28 @@ export class InteractiveSession {
     heartbeatTimeout = null;
     heartbeatTimeoutMs = 300000; // 5 minutes timeout for long AI responses
     lastActivityTime = Date.now();
+    teammateMessageQueue = [];
     // SDK response handling for approvals and questions
     approvalPromises = new Map();
     questionPromises = new Map();
+    // Team mode properties
+    isTeamMode = false;
+    teamId = null;
+    memberId = null;
+    memberName = null;
+    memberRole = null;
+    leadId = null;
+    teamStore = null;
+    messageClient = null;
+    spawnPrompt = null;
+    brokerPort = null;
+    initialTaskId = null;
+    // Operation lock for preventing concurrent operations
+    _isOperationInProgress = false;
+    _shutdownResolver = null;
+    // Queue processing lock to prevent race conditions
+    isProcessingQueue = false;
+    queueProcessingPromise = null;
     constructor(indentLevel = 0) {
         this.rl = readline.createInterface({
             input: process.stdin,
@@ -83,6 +101,47 @@ export class InteractiveSession {
         this.conversationManager = getConversationManager();
         this.sessionManager = getSessionManager(process.cwd());
         this.slashCommandHandler = new SlashCommandHandler();
+        // Check if running in Team Mode
+        if (process.env.XAGENT_TEAM_MODE === 'true') {
+            this.isTeamMode = true;
+            this.teamId = process.env.XAGENT_TEAM_ID || null;
+            this.memberId = process.env.XAGENT_MEMBER_ID || null;
+            this.memberName = process.env.XAGENT_MEMBER_NAME || null;
+            this.memberRole = 'teammate'; // Role is now determined by tool response, not env var
+            this.leadId = process.env.XAGENT_LEAD_ID || null;
+            this.spawnPrompt = process.env.XAGENT_SPAWN_PROMPT || null;
+            this.brokerPort = process.env.XAGENT_BROKER_PORT ? parseInt(process.env.XAGENT_BROKER_PORT, 10) : null;
+            this.initialTaskId = process.env.XAGENT_INITIAL_TASK_ID || null;
+            // Show team role info in welcome message (compact format)
+            console.log(colors.textMuted(`[Team] ${this.memberName} (${this.memberRole})`));
+            // Import and initialize team components
+            import('./team-manager/index.js').then(async ({ getTeamStore, MessageClient, setTeammateClient }) => {
+                this.teamStore = getTeamStore();
+                // Connect to message broker if port is available
+                if (this.brokerPort && this.teamId && this.memberId) {
+                    this.messageClient = new MessageClient(this.teamId, this.memberId, this.brokerPort);
+                    // Save to global singleton for TeamCoordinator to use
+                    setTeammateClient(this.messageClient);
+                    this.messageClient.on('message', (msg) => {
+                        this.handleTeamMessage(msg);
+                    });
+                    this.messageClient.on('connected', () => {
+                        // Silently connected - no output needed
+                    });
+                    this.messageClient.on('disconnected', () => {
+                        // Silently disconnected - no output needed
+                    });
+                    try {
+                        await this.messageClient.connect();
+                    }
+                    catch (err) {
+                        console.error('[Team] Failed to connect to message broker:', err);
+                    }
+                }
+            }).catch(() => {
+                // Ignore import errors
+            });
+        }
         // Register /clear callback, clear local conversation when clearing dialogue
         this.slashCommandHandler.setClearCallback(() => {
             this.conversation = [];
@@ -175,6 +234,208 @@ export class InteractiveSession {
         const toolRegistry = getToolRegistry();
         await toolRegistry.setSdkMode(true, adapter);
     }
+    /**
+     * Handle incoming team message from socket.
+     * Messages are queued and must be explicitly processed by the agent.
+     */
+    handleTeamMessage(msg) {
+        if (!msg || !msg.content)
+            return;
+        let teamMessage;
+        if (msg.type === 'task_update') {
+            let taskInfo;
+            try {
+                const content = typeof msg.content === 'string' ? JSON.parse(msg.content) : msg.content;
+                taskInfo = `Task ${content.action}: ${content.title || content.taskId}`;
+                if (content.assignee) {
+                    taskInfo += ` (assignee: ${content.assignee})`;
+                }
+                if (content.result) {
+                    taskInfo += ` - Result: ${content.result.substring(0, 100)}...`;
+                }
+            }
+            catch {
+                taskInfo = `Task update: ${msg.content}`;
+            }
+            teamMessage = {
+                role: 'user',
+                content: `<system-notification type="task_update">${taskInfo}</system-notification>`,
+                timestamp: msg.timestamp || Date.now()
+            };
+        }
+        else {
+            teamMessage = {
+                role: 'user',
+                content: `<teammate-message from="${msg.fromMemberId}" type="${msg.type}">${msg.content}</teammate-message>`,
+                timestamp: msg.timestamp || Date.now()
+            };
+        }
+        this.teammateMessageQueue.push(teamMessage);
+        // Only start processing if not already processing
+        if (!this.isProcessingQueue && !this._isOperationInProgress) {
+            this.startQueueProcessing();
+        }
+    }
+    /**
+     * Start queue processing with proper locking.
+     */
+    startQueueProcessing() {
+        // Prevent multiple queue processing coroutines
+        if (this.isProcessingQueue) {
+            return;
+        }
+        this.isProcessingQueue = true;
+        this.queueProcessingPromise = this.processMessageQueue();
+        // Handle completion and errors
+        this.queueProcessingPromise
+            .catch((error) => {
+            console.error('[Team] Queue processing error:', error);
+        })
+            .finally(() => {
+            this.isProcessingQueue = false;
+            this.queueProcessingPromise = null;
+        });
+    }
+    /**
+     * Process queued teammate messages one by one.
+     * This method should only be called from startQueueProcessing.
+     */
+    async processMessageQueue() {
+        while (this.teammateMessageQueue.length > 0) {
+            // Check if operation is in progress (e.g., user is typing or another operation)
+            if (this._isOperationInProgress) {
+                // Wait a bit and retry
+                await new Promise(resolve => setTimeout(resolve, 100));
+                continue;
+            }
+            const message = this.teammateMessageQueue.shift();
+            this.conversation.push(message);
+            try {
+                if (this.remoteAIClient) {
+                    await this.generateRemoteResponse(0);
+                }
+                else {
+                    await this.generateResponse(0);
+                }
+            }
+            catch (error) {
+                console.error('[Team] Failed to process teammate message:', error);
+                // Continue processing remaining messages even if one fails
+            }
+        }
+    }
+    /**
+     * Get team mode status.
+     */
+    getIsTeamMode() {
+        return this.isTeamMode;
+    }
+    /**
+     * Get team ID.
+     */
+    getTeamId() {
+        return this.teamId;
+    }
+    /**
+     * Get member ID.
+     */
+    getMemberId() {
+        return this.memberId;
+    }
+    /**
+     * Get member name.
+     */
+    getMemberName() {
+        return this.memberName;
+    }
+    /**
+     * Get lead ID.
+     */
+    getLeadId() {
+        return this.leadId;
+    }
+    /**
+     * Get spawn prompt (for team mode).
+     */
+    getSpawnPrompt() {
+        return this.spawnPrompt;
+    }
+    /**
+     * Get teammate message queue info.
+     */
+    getTeammateMessageQueueInfo() {
+        return {
+            length: this.teammateMessageQueue.length,
+        };
+    }
+    /**
+     * Get and clear all teammate messages from queue.
+     * Returns all pending messages and clears the queue.
+     */
+    popTeammateMessages() {
+        const messages = [...this.teammateMessageQueue];
+        this.teammateMessageQueue = [];
+        return messages;
+    }
+    /**
+     * Connect to team message broker (for lead agent after creating a team).
+     * This allows the lead agent to receive real-time messages from teammates.
+     */
+    async connectToTeamBroker(teamId, memberId, brokerPort) {
+        // Skip if already connected
+        if (this.messageClient) {
+            return;
+        }
+        this.isTeamMode = true;
+        this.teamId = teamId;
+        this.memberId = memberId;
+        this.memberRole = 'lead';
+        this.brokerPort = brokerPort;
+        try {
+            const { getTeamStore, MessageClient } = await import('./team-manager/index.js');
+            this.teamStore = getTeamStore();
+            this.messageClient = new MessageClient(teamId, memberId, brokerPort);
+            this.messageClient.on('message', (msg) => {
+                this.handleTeamMessage(msg);
+            });
+            this.messageClient.on('connected', () => {
+                // Silently connected - no output needed
+            });
+            this.messageClient.on('disconnected', () => {
+                // Silently disconnected - no output needed
+            });
+            await this.messageClient.connect();
+        }
+        catch (err) {
+            console.error(colors.error('[Team] Failed to connect to message broker:'), err);
+            throw err; // Re-throw to let caller handle it
+        }
+    }
+    /**
+     * Cleanup team mode resources.
+     */
+    async cleanupTeamMode() {
+        // Clear teammate's persistent MessageClient if exists
+        const { clearTeammateClient } = await import('./team-manager/index.js');
+        clearTeammateClient();
+        if (this.messageClient) {
+            await this.messageClient.disconnect();
+            this.messageClient = null;
+        }
+        if (this.teamStore && this.teamId && this.memberId) {
+            try {
+                await this.teamStore.updateMember(this.teamId, this.memberId, {
+                    status: 'shutdown',
+                    lastActivity: Date.now()
+                });
+            }
+            catch {
+                // Ignore cleanup errors
+            }
+        }
+        // Reset team mode flag to restore thinking spinner
+        this.isTeamMode = false;
+    }
     /**
      * Get SDK mode status.
      */
@@ -211,7 +472,17 @@ export class InteractiveSession {
         const skillInvoker = (await import('./skill-invoker.js')).getSkillInvoker();
         await skillInvoker.reload();
         const toolRegistry = getToolRegistry();
-        const promptGenerator = new SystemPromptGenerator(toolRegistry, this.executionMode, undefined, this.mcpManager);
+        // Build team context if running in team mode
+        const teamContext = this.isTeamMode ? {
+            teamId: this.teamId,
+            memberId: this.memberId,
+            memberName: this.memberName,
+            memberRole: this.memberRole,
+            leadId: this.leadId || undefined,
+            brokerPort: this.brokerPort || undefined,
+            initialTaskId: this.initialTaskId || undefined,
+        } : undefined;
+        const promptGenerator = new SystemPromptGenerator(toolRegistry, this.executionMode, undefined, this.mcpManager, teamContext);
         // Use the current agent's original system prompt as base
         const baseSystemPrompt = this.currentAgent?.systemPrompt || 'You are xAgent, an AI-powered CLI tool.';
         const newSystemPrompt = await promptGenerator.generateEnhancedSystemPrompt(baseSystemPrompt);
@@ -337,6 +608,28 @@ export class InteractiveSession {
             this._shutdownResolver = resolve;
         });
     }
+    async sendInitialPrompt(prompt) {
+        console.log(colors.textMuted(`\n📋 Initial prompt: ${prompt}\n`));
+        const userMessage = {
+            role: 'user',
+            content: prompt,
+            timestamp: Date.now(),
+        };
+        this.conversation.push(userMessage);
+        await this.conversationManager.addMessage(userMessage);
+        const thinkingConfig = this.configManager.getThinkingConfig();
+        let thinkingTokens = 0;
+        if (thinkingConfig.enabled) {
+            const thinkingMode = detectThinkingKeywords(prompt);
+            thinkingTokens = getThinkingTokens(thinkingMode);
+        }
+        if (this.remoteAIClient) {
+            await this.generateRemoteResponse(thinkingTokens);
+        }
+        else {
+            await this.generateResponse(thinkingTokens);
+        }
+    }
     async initialize() {
         logger.debug('\n[SESSION] ========== initialize() 开始 ==========\n');
         try {
@@ -790,6 +1083,18 @@ export class InteractiveSession {
         if (this._isShuttingDown) {
             return;
         }
+        // Check teammate message queue when agent becomes idle
+        if (this.teammateMessageQueue.length > 0) {
+            await this.processMessageQueue();
+        }
+        // If running in team mode with initial prompt, send it immediately and skip user input
+        if (this.spawnPrompt) {
+            const prompt = this.spawnPrompt;
+            this.spawnPrompt = null;
+            await this.sendInitialPrompt(prompt);
+            this.promptLoop();
+            return;
+        }
         // In SDK mode, use a different input loop
         if (this.isSdkMode) {
             await this.sdkPromptLoop();
@@ -1196,25 +1501,12 @@ export class InteractiveSession {
     async processUserMessage(message, _agent) {
         const inputs = await parseInput(message);
         const textInput = inputs.find((i) => i.type === 'text');
-        const fileInputs = inputs.filter((i) => i.type === 'file');
         const commandInput = inputs.find((i) => i.type === 'command');
         if (commandInput) {
             await this.executeShellCommand(commandInput.content);
             return;
         }
-        let userContent = textInput?.content || '';
-        if (fileInputs.length > 0) {
-            const toolRegistry = getToolRegistry();
-            for (const fileInput of fileInputs) {
-                try {
-                    const content = await toolRegistry.execute('Read', { filePath: fileInput.content }, this.executionMode);
-                    userContent += `\n\n--- File: ${fileInput.content} ---\n${content}`;
-                }
-                catch (error) {
-                    console.log(chalk.yellow(`Warning: Failed to read file ${fileInput.content}: ${error.message}`));
-                }
-            }
-        }
+        const userContent = textInput?.content || '';
         // Record input to session manager
         const sessionInput = {
             type: 'text',
@@ -1323,7 +1615,17 @@ export class InteractiveSession {
         }
         const toolRegistry = getToolRegistry();
         const baseSystemPrompt = this.currentAgent?.systemPrompt || 'You are a helpful AI assistant.';
-        const systemPromptGenerator = new SystemPromptGenerator(toolRegistry, this.executionMode);
+        // Build team context if running in team mode
+        const teamContext = this.isTeamMode ? {
+            teamId: this.teamId,
+            memberId: this.memberId,
+            memberName: this.memberName,
+            memberRole: this.memberRole,
+            leadId: this.leadId || undefined,
+            brokerPort: this.brokerPort || undefined,
+            initialTaskId: this.initialTaskId || undefined,
+        } : undefined;
+        const systemPromptGenerator = new SystemPromptGenerator(toolRegistry, this.executionMode, undefined, undefined, teamContext);
         const enhancedSystemPrompt = await systemPromptGenerator.generateEnhancedSystemPrompt(baseSystemPrompt);
         const result = await this.contextCompressor.compressContext(this.conversation, enhancedSystemPrompt, compressionConfig);
         if (result.wasCompressed) {
@@ -1487,8 +1789,8 @@ export class InteractiveSession {
         const icon = colors.primary(icons.brain);
         const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
         let frameIndex = 0;
-        // SDK 模式下不显示 spinner
-        const showThinkingSpinner = !this.isSdkMode;
+        // SDK 模式和 Team 模式下不显示 spinner (team 模式下 teammate 输出会与 spinner 混淆)
+        const showThinkingSpinner = !this.isSdkMode && !this.isTeamMode;
         let spinnerInterval = null;
         // Custom spinner: only icon rotates, text stays static
         if (showThinkingSpinner) {
@@ -1514,7 +1816,17 @@ export class InteractiveSession {
                     allowedToolNames.includes(tool.function.name))
                 : toolDefinitions;
             const baseSystemPrompt = this.currentAgent?.systemPrompt ?? '';
-            const systemPromptGenerator = new SystemPromptGenerator(toolRegistry, this.executionMode, undefined, this.mcpManager);
+            // Build team context if running in team mode
+            const teamContext = this.isTeamMode ? {
+                teamId: this.teamId,
+                memberId: this.memberId,
+                memberName: this.memberName,
+                memberRole: this.memberRole,
+                leadId: this.leadId || undefined,
+                brokerPort: this.brokerPort || undefined,
+                initialTaskId: this.initialTaskId || undefined,
+            } : undefined;
+            const systemPromptGenerator = new SystemPromptGenerator(toolRegistry, this.executionMode, undefined, this.mcpManager, teamContext);
             const enhancedSystemPrompt = await systemPromptGenerator.generateEnhancedSystemPrompt(baseSystemPrompt);
             const messages = [
                 { role: 'system', content: `${enhancedSystemPrompt}\n\n${memory}`, timestamp: Date.now() },
@@ -2444,4 +2756,24 @@ export function setSingletonSession(session) {
 export function getSingletonSession() {
     return singletonSession;
 }
+/**
+ * Get teammate message queue info from the singleton session.
+ * Returns queue length.
+ */
+export function getTeammateMessageQueueInfo() {
+    if (!singletonSession) {
+        return null;
+    }
+    return singletonSession.getTeammateMessageQueueInfo();
+}
+/**
+ * Get and clear all teammate messages from the singleton session.
+ * Returns all pending messages and clears the queue.
+ */
+export function popTeammateMessages() {
+    if (!singletonSession) {
+        return null;
+    }
+    return singletonSession.popTeammateMessages();
+}
 //# sourceMappingURL=session.js.map