crewly 1.1.2 → 1.2.0

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

@@ -1,6 +1,6 @@
 import * as path from 'path';
 import * as os from 'os';
-import { readFile, readdir, stat, mkdir, writeFile } from 'fs/promises';
+import { readFile, readdir, stat, mkdir, writeFile, access } from 'fs/promises';
 import { LoggerService } from '../core/logger.service.js';
 import { createSessionCommandHelper, getSessionBackendSync, createSessionBackend, getSessionStatePersistence, } from '../session/index.js';
 import { RuntimeServiceFactory } from './runtime-service.factory.js';
@@ -13,6 +13,7 @@ import { RuntimeExitMonitorService } from './runtime-exit-monitor.service.js';
 import { ContextWindowMonitorService } from './context-window-monitor.service.js';
 import { SubAgentMessageQueue } from '../messaging/sub-agent-message-queue.service.js';
 import { AgentSuspendService } from './agent-suspend.service.js';
+import { stripAnsiCodes } from '../../utils/terminal-output.utils.js';
 /**
  * Service responsible for the complex, multi-step process of agent initialization and registration.
  * Isolates the complex state management of agent startup with progressive escalation.
@@ -187,11 +188,17 @@ export class AgentRegistrationService {
             for (const excluded of (excludedRoleSkills || [])) {
                 effectiveSkills.delete(excluded);
             }
-            // 3. For each skill, read skill.json and collect flags matching runtime
+            // 3. For each skill, read skill.json and collect flags matching runtime.
+            //    Skills live under agent/core/ or agent/marketplace/ subdirectories,
+            //    so search both paths when looking up skill.json.
             for (const skillId of effectiveSkills) {
                 try {
-                    const skillPath = path.join(this.projectRoot, 'config', 'skills', skillId, 'skill.json');
-                    const skillContent = await readFile(skillPath, 'utf8');
+                    const skillJsonPath = await this.findSkillJsonPath(skillId);
+                    if (!skillJsonPath) {
+                        this.logger.warn('Skill config not found in any known directory', { skillId });
+                        continue;
+                    }
+                    const skillContent = await readFile(skillJsonPath, 'utf8');
                     const skillConfig = JSON.parse(skillContent);
                     if (skillConfig.runtime?.runtime === runtimeType && Array.isArray(skillConfig.runtime?.flags)) {
                         for (const flag of skillConfig.runtime.flags) {
@@ -199,8 +206,11 @@ export class AgentRegistrationService {
                         }
                     }
                 }
-                catch {
-                    // Skill config not found — skip silently
+                catch (skillErr) {
+                    this.logger.warn('Failed to read skill config', {
+                        skillId,
+                        error: skillErr instanceof Error ? skillErr.message : String(skillErr),
+                    });
                 }
             }
             if (flags.size > 0) {
@@ -216,6 +226,29 @@ export class AgentRegistrationService {
         }
         return Array.from(flags);
     }
+    /**
+     * Search known skill directories for a skill's skill.json file.
+     * Skills live under `config/skills/agent/core/` or `config/skills/agent/marketplace/`.
+     *
+     * @param skillId - The skill identifier (directory name)
+     * @returns Absolute path to skill.json, or null if not found
+     */
+    async findSkillJsonPath(skillId) {
+        const searchDirs = [
+            path.join(this.projectRoot, 'config', 'skills', 'agent', 'core', skillId, 'skill.json'),
+            path.join(this.projectRoot, 'config', 'skills', 'agent', 'marketplace', skillId, 'skill.json'),
+        ];
+        for (const candidate of searchDirs) {
+            try {
+                await access(candidate);
+                return candidate;
+            }
+            catch {
+                // Not found in this directory, try next
+            }
+        }
+        return null;
+    }
     /**
      * Create a runtime service instance for the given runtime type.
      * Centralizes RuntimeServiceFactory creation to reduce code duplication.
@@ -422,9 +455,26 @@ export class AgentRegistrationService {
         // Must be before postInitialize and sendRegistrationPromptAsync so exits
         // during those phases are detected and the abort signal fires in time.
         RuntimeExitMonitorService.getInstance().startMonitoring(sessionName, runtimeType, role);
+        // Look up per-agent browser automation override from member config
+        let browserAutomationOverride;
+        if (memberId) {
+            try {
+                const teams = await this.storageService.getTeams();
+                for (const team of teams) {
+                    const member = team.members?.find((m) => m.id === memberId || m.sessionName === sessionName);
+                    if (member?.enableBrowserAutomation !== undefined) {
+                        browserAutomationOverride = member.enableBrowserAutomation;
+                        break;
+                    }
+                }
+            }
+            catch {
+                // Non-fatal — will use global setting
+            }
+        }
         // Run post-initialization hook (e.g., Gemini CLI directory allowlist)
         try {
-            await runtimeService2.postInitialize(sessionName, projectPath, additionalAllowlistPaths);
+            await runtimeService2.postInitialize(sessionName, projectPath, additionalAllowlistPaths, browserAutomationOverride);
             // Drain stale terminal escape sequences (e.g. DA1 [?1;2c) that may have
             // arrived during postInitialize commands, so they don't leak into the prompt input
             await delay(500);
@@ -684,10 +734,27 @@ export class AgentRegistrationService {
             // Start runtime exit monitoring immediately after runtime is ready
             RuntimeExitMonitorService.getInstance().startMonitoring(sessionName, runtimeType, role);
         }
+        // Look up per-agent browser automation override from member config
+        let browserOverrideForRecreation;
+        if (memberId) {
+            try {
+                const teams = await this.storageService.getTeams();
+                for (const team of teams) {
+                    const member = team.members?.find((m) => m.id === memberId || m.sessionName === sessionName);
+                    if (member?.enableBrowserAutomation !== undefined) {
+                        browserOverrideForRecreation = member.enableBrowserAutomation;
+                        break;
+                    }
+                }
+            }
+            catch {
+                // Non-fatal — will use global setting
+            }
+        }
         // Run post-initialization hook (e.g., Gemini CLI directory allowlist)
         try {
             const postInitService = this.createRuntimeService(runtimeType);
-            await postInitService.postInitialize(sessionName, projectPath);
+            await postInitService.postInitialize(sessionName, projectPath, undefined, browserOverrideForRecreation);
             // Drain stale terminal escape sequences (e.g. DA1 [?1;2c) that may have
             // arrived during postInitialize commands, so they don't leak into the prompt input
             await delay(500);
@@ -1742,7 +1809,10 @@ After checking in, just say "Ready for tasks" and wait for me to send you work.`
             const unsubscribe = session.onData((data) => {
                 if (resolved)
                     return;
-                if (streamPattern.test(data)) {
+                // Strip ANSI escape sequences before testing — raw PTY data contains
+                // cursor positioning, color codes, etc. that break regex matching (#106)
+                const cleanData = stripAnsiCodes(data);
+                if (streamPattern.test(cleanData)) {
                     // Double-check with capturePane to avoid false positives from partial data
                     const output = sessionHelper.capturePane(sessionName);
                     if (this.isClaudeAtPrompt(output, runtimeType)) {
@@ -2035,11 +2105,25 @@ After checking in, just say "Ready for tasks" and wait for me to send you work.`
                 // Verify agent is at prompt before sending
                 const output = sessionHelper.capturePane(sessionName);
                 if (!this.isClaudeAtPrompt(output, runtimeType)) {
-                    // On the final attempt, fall back to direct delivery rather than
-                    // returning a 502 error. The agent may be at a prompt that doesn't
-                    // match our detection patterns, or the terminal buffer may be stale.
-                    // This mirrors what the /write endpoint does successfully.
                     if (attempt === maxAttempts) {
+                        // On the final attempt, check if the agent is DEFINITELY busy
+                        // before force-delivering. If we see "esc to interrupt" or
+                        // processing indicators, the agent is actively working and
+                        // force-delivery risks corrupting its current task.
+                        const tailForBusyCheck = output.slice(-2000);
+                        const isBusy = TERMINAL_PATTERNS.BUSY_STATUS_BAR.test(tailForBusyCheck) ||
+                            TERMINAL_PATTERNS.PROCESSING_WITH_TEXT.test(tailForBusyCheck);
+                        if (isBusy) {
+                            this.logger.warn('Agent is busy (processing indicators detected), skipping force delivery', {
+                                sessionName,
+                                attempt,
+                                runtimeType,
+                            });
+                            return false;
+                        }
+                        // Not clearly busy — fall back to direct delivery. The agent
+                        // may be at a prompt that doesn't match our detection patterns,
+                        // or the terminal buffer may be stale.
                         this.logger.warn('Prompt detection failed on final attempt, delivering message directly', {
                             sessionName,
                             attempt,
@@ -2096,9 +2180,18 @@ After checking in, just say "Ready for tasks" and wait for me to send you work.`
                     }
                 }
                 else {
-                    // On retry attempts (2+), force a PTY resize to trigger SIGWINCH.
-                    // This makes Ink re-render the TUI, potentially restoring focus state.
-                    if (attempt > 1) {
+                    // Detect recent /compress — Ink TUI loses internal focus after
+                    // /compress re-renders, causing subsequent messages to be silently
+                    // dropped even though the prompt `>` is visible (#114).
+                    // Always force PTY resize on attempt 1 if /compress detected.
+                    const recentOutput = sessionHelper.capturePane(sessionName, 40);
+                    const compressDetected = recentOutput.includes('/compress') ||
+                        recentOutput.includes('Context compressed') ||
+                        recentOutput.includes('Compressing context');
+                    const needsResize = attempt > 1 || compressDetected;
+                    // Force a PTY resize to trigger SIGWINCH, making Ink
+                    // re-render the TUI and potentially restore focus state.
+                    if (needsResize) {
                         try {
                             const session = sessionHelper.getSession(sessionName);
                             if (session) {
@@ -2110,6 +2203,7 @@ After checking in, just say "Ready for tasks" and wait for me to send you work.`
                                 this.logger.debug('PTY resize sent to trigger TUI re-render', {
                                     sessionName,
                                     attempt,
+                                    compressDetected,
                                 });
                             }
                         }
@@ -2131,7 +2225,8 @@ After checking in, just say "Ready for tasks" and wait for me to send you work.`
                     // the input is engaged. Enter on an empty `> ` prompt is a
                     // safe no-op (just shows a new blank prompt line).
                     await sessionHelper.sendEnter(sessionName);
-                    await delay(500);
+                    // Extra settling time after /compress to let Ink TUI stabilize
+                    await delay(compressDetected ? 1000 : 500);
                 }
                 // For Gemini CLI: detect and gently escape interactive modes before
                 // sending the message. Avoid Ctrl-C here — Gemini interprets it as
@@ -2400,7 +2495,12 @@ After checking in, just say "Ready for tasks" and wait for me to send you work.`
                             || hasProcessingIndicators
                             || hasGeminiIndicators;
                         if (delivered) {
-                            this.logger.debug('Message delivered successfully (TUI output changed)', {
+                            // 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)`, {
                                 sessionName,
                                 attempt,
                                 lengthDiff,
@@ -2408,6 +2508,7 @@ After checking in, just say "Ready for tasks" and wait for me to send you work.`
                                 hasProcessingIndicators,
                                 hasGeminiIndicators,
                                 newContentLength: newContent.length,
+                                signal: hasStrongSignal ? 'processing-indicators' : 'output-length-change-only',
                             });
                             return true;
                         }
@@ -2460,6 +2561,19 @@ After checking in, just say "Ready for tasks" and wait for me to send you work.`
                 }
             }
         }
+        // Verification failed, but the message was physically written to the PTY.
+        // If the session is still alive, the agent will likely process it — return
+        // true to avoid false "Failed to deliver" errors shown to users (#99).
+        const backend = getSessionBackendSync();
+        const childAlive = backend?.isChildProcessAlive?.(sessionName);
+        if (childAlive !== false) {
+            this.logger.warn('Message delivery verification inconclusive but session alive — assuming success', {
+                sessionName,
+                maxAttempts,
+                messageLength: message.length,
+            });
+            return true;
+        }
         this.logger.error('Message delivery failed after all retry attempts', {
             sessionName,
             maxAttempts,
@@ -2822,11 +2936,14 @@ After checking in, just say "Ready for tasks" and wait for me to send you work.`
         return TERMINAL_PATTERNS.PROMPT_STREAM;
     }
     /**
-     * Check if Claude Code appears to be at an input prompt.
-     * Looks for common prompt indicators in terminal output.
+     * Check if the agent appears to be at an input prompt.
+     * Looks for prompt indicators (❯, ⏵, $, ❯❯, ⏵⏵) in terminal output.
+     * Also checks for busy indicators (esc to interrupt, spinners, ⏺)
+     * to avoid false negatives when the agent is processing.
      *
      * @param terminalOutput - The terminal output to check
-     * @returns true if Claude Code appears to be at a prompt
+     * @param runtimeType - The runtime type for pattern selection
+     * @returns true if the agent appears to be at a prompt
      */
     isClaudeAtPrompt(terminalOutput, runtimeType) {
         // Handle null/undefined/empty input — return false since an empty buffer
@@ -2835,8 +2952,10 @@ After checking in, just say "Ready for tasks" and wait for me to send you work.`
             this.logger.debug('Terminal output is empty or invalid, cannot detect prompt', { runtimeType });
             return false;
         }
-        // Only analyze the tail of the buffer to avoid matching historical prompts
-        const tailSection = terminalOutput.slice(-2000);
+        // Only analyze the tail of the buffer to avoid matching historical prompts.
+        // Use 5000 chars to accommodate large tool outputs that push the prompt
+        // further back in the buffer (#106).
+        const tailSection = terminalOutput.slice(-5000);
         const isGemini = runtimeType === RUNTIME_TYPES.GEMINI_CLI;
         const isClaudeCode = runtimeType === RUNTIME_TYPES.CLAUDE_CODE;
         const isCodex = runtimeType === RUNTIME_TYPES.CODEX_CLI;
@@ -2854,8 +2973,11 @@ After checking in, just say "Ready for tasks" and wait for me to send you work.`
         const linesToCheck = lines.slice(-10);
         const hasPrompt = linesToCheck.some((line) => {
             const trimmed = line.trim();
-            // Strip TUI box-drawing borders (│, ┃, etc.) that Gemini CLI wraps around prompts
-            const stripped = trimmed.replace(/^[│┃|]+\s*/, '').replace(/\s*[│┃|]+$/, '');
+            // Strip TUI box-drawing borders that Gemini CLI and other TUI frameworks
+            // wrap around prompts. Covers full Unicode box-drawing range (#106).
+            const stripped = trimmed
+                .replace(/^[\u2500-\u257F|+\-═║╭╮╰╯]+\s*/, '')
+                .replace(/\s*[\u2500-\u257F|+\-═║╭╮╰╯]+$/, '');
             // Claude Code prompts: ❯, ⏵, $ alone on a line
             if (!isGemini && !isCodex) {
                 if (['❯', '⏵', '$'].some(ch => trimmed === ch || stripped === ch)) {
@@ -2863,7 +2985,8 @@ After checking in, just say "Ready for tasks" and wait for me to send you work.`
                 }
                 // ❯❯ = bypass permissions prompt (idle).
                 // Matches "❯❯", "❯❯ ", and "❯❯ bypass permissions on (shift+tab to cycle)".
-                // This line disappears during processing and reappears when idle.
+                // Note: ⏵⏵ appears in the status bar but is visible both when idle AND
+                // busy, so it cannot be used as a reliable prompt indicator.
                 if (trimmed.startsWith('❯❯')) {
                     return true;
                 }
@@ -2887,13 +3010,21 @@ After checking in, just say "Ready for tasks" and wait for me to send you work.`
         if (hasPrompt) {
             return true;
         }
-        // No prompt found — check if still processing. Only check the last few
-        // lines to avoid matching words like "thinking" in historical response text.
-        const recentLines = linesToCheck.slice(-5).join('\n');
+        // No prompt found — check if still processing.
+        // Check last 10 lines (not just 5) because tool output can push processing
+        // indicators further up while the status bar stays at the bottom.
+        const recentLines = linesToCheck.join('\n');
         if (TERMINAL_PATTERNS.PROCESSING_WITH_TEXT.test(recentLines)) {
             this.logger.debug('Processing indicators present near bottom of output');
             return false;
         }
+        // Check for "esc to interrupt" in the status bar — this is a definitive
+        // busy signal. Claude Code only shows this text while actively processing.
+        // It disappears when the agent returns to idle at the prompt.
+        if (TERMINAL_PATTERNS.BUSY_STATUS_BAR.test(recentLines)) {
+            this.logger.debug('Busy status bar detected (esc to interrupt)');
+            return false;
+        }
         this.logger.debug('No prompt detected in terminal output', {
             tailLength: tailSection.length,
             lastLines: linesToCheck.slice(-3).map(l => l.substring(0, 80)),