crewly 1.2.7 → 1.2.8

package/dist/backend/backend/src/services/agent/agent-registration.service.js

@@ -16,7 +16,7 @@ import { SubAgentMessageQueue } from '../messaging/sub-agent-message-queue.servi
 import { AgentSuspendService } from './agent-suspend.service.js';
 import { PromptBuilderService } from '../ai/prompt-builder.service.js';
 import { stripAnsiCodes } from '../../utils/terminal-output.utils.js';
-import { isPromptLine, containsSpinnerOrWorkingIndicator, containsProcessingIndicator, containsBusyStatusBar, containsRewindMode, containsGeminiProcessingKeywords, extractChatPrefix, stripTuiLineBorders, matchTuiPromptLine, } from '../../utils/terminal-string-ops.js';
+import { isPromptLine, containsSpinnerOrWorkingIndicator, containsProcessingIndicator, containsBusyStatusBar, containsRewindMode, extractChatPrefix, stripTuiLineBorders, matchTuiPromptLine, } from '../../utils/terminal-string-ops.js';
 import { PtyActivityTrackerService } from './pty-activity-tracker.service.js';
 /**
  * Service responsible for the complex, multi-step process of agent initialization and registration.
@@ -1617,13 +1617,24 @@ After checking in, just say "Ready for tasks" and wait for me to send you work.`
             await sessionHelper.setEnvironmentVariable(sessionName, ENV_CONSTANTS.CREWLY_SESSION_NAME, sessionName);
             await sessionHelper.setEnvironmentVariable(sessionName, ENV_CONSTANTS.CREWLY_ROLE, role);
             await sessionHelper.setEnvironmentVariable(sessionName, ENV_CONSTANTS.CREWLY_API_URL, `http://localhost:${WEB_CONSTANTS.PORTS.BACKEND}`);
-            // Pass Gemini API key to gemini-cli agents so they authenticate
-            // with the paid API key instead of the free-tier Google login.
-            if (runtimeType === RUNTIME_TYPES.GEMINI_CLI) {
-                const geminiApiKey = process.env[ENV_CONSTANTS.GEMINI_API_KEY];
-                if (geminiApiKey) {
-                    await sessionHelper.setEnvironmentVariable(sessionName, ENV_CONSTANTS.GEMINI_API_KEY, geminiApiKey);
-                }
+            // Inject API keys from settings (with override chain) for all runtimes
+            const settingsService = getSettingsService();
+            const runtimeContext = { runtime: runtimeType };
+            // Gemini key — needed by gemini-cli and crewly-agent
+            const geminiKey = await settingsService.getApiKey('gemini', runtimeContext);
+            if (geminiKey) {
+                await sessionHelper.setEnvironmentVariable(sessionName, 'GOOGLE_GENERATIVE_AI_API_KEY', geminiKey);
+                await sessionHelper.setEnvironmentVariable(sessionName, ENV_CONSTANTS.GEMINI_API_KEY, geminiKey);
+            }
+            // Anthropic key — needed by claude-code and crewly-agent
+            const anthropicKey = await settingsService.getApiKey('anthropic', runtimeContext);
+            if (anthropicKey) {
+                await sessionHelper.setEnvironmentVariable(sessionName, 'ANTHROPIC_API_KEY', anthropicKey);
+            }
+            // OpenAI key — needed by codex-cli and crewly-agent
+            const openaiKey = await settingsService.getApiKey('openai', runtimeContext);
+            if (openaiKey) {
+                await sessionHelper.setEnvironmentVariable(sessionName, 'OPENAI_API_KEY', openaiKey);
             }
             this.logger.info('Agent session created and environment variables set, initializing with registration', {
                 sessionName,
@@ -1849,8 +1860,13 @@ After checking in, just say "Ready for tasks" and wait for me to send you work.`
                     error: 'Runtime has exited — no child process in session',
                 };
             }
-            // Use robust message delivery with proper waiting mechanism
-            const delivered = await this.sendMessageWithRetry(sessionName, message, 3, runtimeType);
+            // Use robust message delivery with proper waiting mechanism.
+            // Gemini CLI: reduce maxAttempts to 1 — the heavy retry loop with
+            // Tab+Enter recovery causes visible error spam while messages are
+            // actually delivered successfully. The PTY write is reliable; it's
+            // the verification that misjudges delivery as failed.
+            const maxDeliveryAttempts = runtimeType === RUNTIME_TYPES.GEMINI_CLI ? 1 : 3;
+            const delivered = await this.sendMessageWithRetry(sessionName, message, maxDeliveryAttempts, runtimeType);
             if (!delivered) {
                 // Check if the agent is actively processing (busy) — the queue
                 // processor can re-queue instead of permanently failing the message.
@@ -2462,94 +2478,107 @@ After checking in, just say "Ready for tasks" and wait for me to send you work.`
                     }
                 }
                 else {
-                    // --- Phase 1: Direct stuck-at-prompt detection ---
-                    // Check if our message text is literally sitting on the `> ` prompt
-                    // line. This is the definitive signal that Enter was not pressed or
-                    // was silently consumed by the TUI. Unlike output-change detection,
-                    // this has no false positives from TUI redraws or historical text.
-                    const stuckAtPrompt = this.isTextStuckAtTuiPrompt(sessionName, message);
-                    if (stuckAtPrompt) {
-                        // Attempt immediate recovery: press Enter to submit the text
-                        const recovered = await this.recoverStuckTuiMessage(sessionName, message);
-                        if (recovered) {
-                            this.logger.info('Message recovered via Enter re-press', {
+                    // --- Gemini CLI: lightweight verification ---
+                    // Gemini CLI's PTY write is reliable. The aggressive verification
+                    // (stuck detection + Tab+Enter recovery + output-change diff) causes
+                    // false "stuck" judgments that trigger visible retry error spam even
+                    // when the message was successfully delivered (#retry-storm fix).
+                    //
+                    // Strategy: only check for the definitive stuck signal (message text
+                    // literally sitting on the `> ` prompt line). If not stuck, trust the
+                    // write. Skip the output-change heuristics that cause false negatives.
+                    const isGemini = runtimeType === RUNTIME_TYPES.GEMINI_CLI;
+                    if (isGemini) {
+                        // Single stuck-at-prompt check — the only reliable failure signal
+                        const stuckAtPrompt = this.isTextStuckAtTuiPrompt(sessionName, message);
+                        if (stuckAtPrompt) {
+                            const recovered = await this.recoverStuckTuiMessage(sessionName, message);
+                            if (recovered) {
+                                this.logger.info('Gemini CLI: message recovered via Enter re-press', {
+                                    sessionName,
+                                    attempt,
+                                });
+                                return true;
+                            }
+                            this.logger.warn('Gemini CLI: message still stuck after Enter recovery', {
+                                sessionName,
+                                attempt,
+                            });
+                            // Fall through to retry cleanup below
+                        }
+                        else {
+                            // Not stuck at prompt — PTY write succeeded, trust delivery.
+                            // The old code did output-change detection here, but TUI redraws
+                            // and minimal length diffs caused false "not delivered" verdicts.
+                            this.logger.debug('Gemini CLI: message not stuck at prompt — delivery trusted', {
                                 sessionName,
                                 attempt,
                             });
                             return true;
                         }
-                        // Still stuck after recovery — fall through to retry with cleanup
-                        this.logger.warn('Message still stuck after Enter recovery, will retry', {
-                            sessionName,
-                            attempt,
-                        });
-                        // Skip the output-change check — we know it's stuck
                     }
                     else {
-                        // --- Phase 2: Output-change detection ---
-                        // Text is NOT on the prompt line. Either it was delivered (Enter
-                        // worked) or it was never written (TUI was defocused and the Ink
-                        // framework consumed the text silently). Compare output snapshots.
-                        const afterOutput = sessionHelper.capturePane(sessionName, 20);
-                        const lengthDiff = afterOutput.length - beforeLength;
-                        const contentChanged = beforeOutput !== afterOutput;
-                        // CRITICAL: Only check for processing indicators in NEW content
-                        // (the diff between before and after). Checking the full afterOutput
-                        // causes false positives because words like "generating", "searching"
-                        // commonly appear in the agent's previous response text visible in
-                        // the 20-line capture.
-                        let newContent = '';
-                        if (contentChanged && afterOutput.length > beforeOutput.length) {
-                            newContent = afterOutput.slice(beforeLength);
-                        }
-                        else if (contentChanged) {
-                            const beforeLines = new Set(beforeOutput.split('\n'));
-                            newContent = afterOutput
-                                .split('\n')
-                                .filter((line) => !beforeLines.has(line))
-                                .join('\n');
+                        // --- Non-Gemini TUI runtimes: full verification ---
+                        // Phase 1: Direct stuck-at-prompt detection
+                        const stuckAtPrompt = this.isTextStuckAtTuiPrompt(sessionName, message);
+                        if (stuckAtPrompt) {
+                            const recovered = await this.recoverStuckTuiMessage(sessionName, message);
+                            if (recovered) {
+                                this.logger.info('Message recovered via Enter re-press', {
+                                    sessionName,
+                                    attempt,
+                                });
+                                return true;
+                            }
+                            this.logger.warn('Message still stuck after Enter recovery, will retry', {
+                                sessionName,
+                                attempt,
+                            });
                         }
-                        const hasProcessingIndicators = containsProcessingIndicator(newContent || afterOutput.slice(-500));
-                        const hasGeminiIndicators = newContent.length > 0
-                            && containsGeminiProcessingKeywords(newContent);
-                        const significantLengthChange = Math.abs(lengthDiff) > 10;
-                        // For Gemini CLI, contentChanged alone is sufficient evidence of
-                        // delivery. The TUI redraws minimally (lengthDiff can be as low as
-                        // 1-2 chars) when processing starts, so requiring significantLengthChange
-                        // causes false "stuck" detection. False "stuck" + Ctrl+C kills the CLI.
-                        const isGemini = runtimeType === RUNTIME_TYPES.GEMINI_CLI;
-                        const delivered = (lengthDiff > 20)
-                            || (contentChanged && significantLengthChange)
-                            || (contentChanged && isGemini)
-                            || hasProcessingIndicators
-                            || hasGeminiIndicators;
-                        if (delivered) {
-                            // Log at warn level when verification passed on weak signals
-                            // (output length change only, no explicit processing indicators)
-                            // so future false positives are traceable in logs.
-                            const hasStrongSignal = hasProcessingIndicators || hasGeminiIndicators;
-                            const logLevel = hasStrongSignal ? 'debug' : 'warn';
-                            this.logger[logLevel](`Message delivery verified (${hasStrongSignal ? 'strong' : 'weak'} signal)`, {
+                        else {
+                            // Phase 2: Output-change detection
+                            const afterOutput = sessionHelper.capturePane(sessionName, 20);
+                            const lengthDiff = afterOutput.length - beforeLength;
+                            const contentChanged = beforeOutput !== afterOutput;
+                            let newContent = '';
+                            if (contentChanged && afterOutput.length > beforeOutput.length) {
+                                newContent = afterOutput.slice(beforeLength);
+                            }
+                            else if (contentChanged) {
+                                const beforeLines = new Set(beforeOutput.split('\n'));
+                                newContent = afterOutput
+                                    .split('\n')
+                                    .filter((line) => !beforeLines.has(line))
+                                    .join('\n');
+                            }
+                            const hasProcessingIndicators = containsProcessingIndicator(newContent || afterOutput.slice(-500));
+                            const significantLengthChange = Math.abs(lengthDiff) > 10;
+                            const delivered = (lengthDiff > 20)
+                                || (contentChanged && significantLengthChange)
+                                || hasProcessingIndicators;
+                            if (delivered) {
+                                const hasStrongSignal = hasProcessingIndicators;
+                                const logLevel = hasStrongSignal ? 'debug' : 'warn';
+                                this.logger[logLevel](`Message delivery verified (${hasStrongSignal ? 'strong' : 'weak'} signal)`, {
+                                    sessionName,
+                                    attempt,
+                                    lengthDiff,
+                                    contentChanged,
+                                    hasProcessingIndicators,
+                                    newContentLength: newContent.length,
+                                    signal: hasStrongSignal ? 'processing-indicators' : 'output-length-change-only',
+                                });
+                                return true;
+                            }
+                            this.logger.warn('TUI output did not change after send — message may not have been accepted', {
                                 sessionName,
                                 attempt,
                                 lengthDiff,
                                 contentChanged,
                                 hasProcessingIndicators,
-                                hasGeminiIndicators,
                                 newContentLength: newContent.length,
-                                signal: hasStrongSignal ? 'processing-indicators' : 'output-length-change-only',
                             });
-                            return true;
                         }
-                        this.logger.warn('TUI output did not change after send — message may not have been accepted', {
-                            sessionName,
-                            attempt,
-                            lengthDiff,
-                            contentChanged,
-                            hasProcessingIndicators,
-                            hasGeminiIndicators,
-                            newContentLength: newContent.length,
-                        });
                     }
                 }
                 // Message stuck at prompt — clear line and retry.