agent-relay 1.2.0 → 1.3.0

package/dist/wrapper/pty-wrapper.js

@@ -4,55 +4,42 @@
  * Unlike TmuxWrapper which provides interactive terminal access,
  * PtyWrapper runs agents headlessly with output capture for logs.
  * Used for spawned workers that don't need direct user interaction.
+ *
+ * Extends BaseWrapper for shared message handling, spawn/release,
+ * and continuity integration.
  */
 import * as pty from 'node-pty';
 import fs from 'node:fs';
 import path from 'node:path';
-import { EventEmitter } from 'node:events';
-import { RelayClient } from './client.js';
+import { BaseWrapper } from './base-wrapper.js';
 import { parseSummaryWithDetails, parseSessionEndFromOutput, isPlaceholderTarget } from './parser.js';
 import { getProjectPaths } from '../utils/project-namespace.js';
 import { getTrailEnvVars } from '../trajectory/integration.js';
 import { findAgentConfig } from '../utils/agent-config.js';
 import { HookRegistry, createTrajectoryHooks } from '../hooks/index.js';
-import { getContinuityManager, parseContinuityCommand, hasContinuityCommand } from '../continuity/index.js';
-import { INJECTION_CONSTANTS, stripAnsi, sleep, buildInjectionString, injectWithRetry as sharedInjectWithRetry, calculateSuccessRate, createInjectionMetrics, getDefaultRelayPrefix, detectCliType, CLI_QUIRKS, } from './shared.js';
+import { parseContinuityCommand, hasContinuityCommand } from '../continuity/index.js';
+import { INJECTION_CONSTANTS, stripAnsi, sleep, buildInjectionString, injectWithRetry as sharedInjectWithRetry, CLI_QUIRKS, } from './shared.js';
+import { detectProviderAuthRevocation } from './auth-detection.js';
 /** Maximum lines to keep in output buffer */
 const MAX_BUFFER_LINES = 10000;
-export class PtyWrapper extends EventEmitter {
+export class PtyWrapper extends BaseWrapper {
+    // Override config with PtyWrapper-specific type
     config;
+    // PTY-specific state
     ptyProcess;
-    client;
-    running = false;
     outputBuffer = [];
     rawBuffer = '';
-    relayPrefix;
-    cliType;
-    sentMessageHashes = new Set();
-    receivedMessageIds = new Set(); // Dedup incoming messages
-    processedSpawnCommands = new Set();
-    processedReleaseCommands = new Set();
-    pendingFencedSpawn = null;
-    messageQueue = [];
-    isInjecting = false;
     readyForMessages = false;
     lastOutputTime = 0;
-    injectionMetrics = createInjectionMetrics();
     logFilePath;
     logStream;
     acceptedPrompts = new Set(); // Track which prompts have been accepted
     hookRegistry;
     sessionStartTime = Date.now();
-    continuity;
-    agentId;
-    processedContinuityCommands = new Set();
-    lastSummaryRawContent = ''; // Dedup summary event emissions
-    sessionEndProcessed = false; // Track if we've already emitted session-end
     inThinkingBlock = false; // Track if inside <thinking>...</thinking>
     lastSummaryTime = Date.now(); // Track when last summary was output
     outputsSinceSummary = 0; // Count outputs since last summary
     detectedTask; // Auto-detected task from agent config
-    sessionEndData; // Store SESSION_END data for handoff
     instructionsInjected = false; // Track if init instructions have been injected
     continuityInjected = false; // Track if continuity context has been injected
     recentLogChunks = new Map(); // Dedup log streaming (hash -> timestamp)
@@ -60,12 +47,13 @@ export class PtyWrapper extends EventEmitter {
     static LOG_DEDUP_MAX_SIZE = 100; // Max entries in dedup map
     lastParsedLength = 0; // Track last parsed position to avoid re-parsing entire buffer
     lastContinuityParsedLength = 0; // Same for continuity commands
+    // Auth revocation detection state
+    authRevoked = false;
+    lastAuthCheck = 0;
+    AUTH_CHECK_INTERVAL = 5000; // Check every 5 seconds max
     constructor(config) {
-        super();
+        super(config);
         this.config = config;
-        this.relayPrefix = config.relayPrefix ?? getDefaultRelayPrefix();
-        // Detect CLI type from command for special handling
-        this.cliType = config.cliType ?? detectCliType(config.command);
         // Auto-detect agent role from .claude/agents/ or .openagents/ if task not provided
         let detectedTask = config.task;
         if (!detectedTask) {
@@ -78,15 +66,7 @@ export class PtyWrapper extends EventEmitter {
         }
         // Store detected task for use in hook registry
         this.detectedTask = detectedTask;
-        this.client = new RelayClient({
-            agentName: config.name,
-            socketPath: config.socketPath,
-            cli: this.cliType,
-            task: detectedTask,
-            workingDirectory: config.cwd ?? process.cwd(),
-            quiet: true,
-        });
-        // Initialize hook registry
+        // Initialize hook registry (PTY-specific)
         const projectPaths = getProjectPaths();
         this.hookRegistry = new HookRegistry({
             agentName: config.name,
@@ -112,13 +92,29 @@ export class PtyWrapper extends EventEmitter {
         if (config.hooks) {
             this.hookRegistry.registerLifecycleHooks(config.hooks);
         }
-        // Initialize continuity manager
-        this.continuity = getContinuityManager({ defaultCli: 'spawned' });
-        // Handle incoming messages
-        this.client.onMessage = (from, payload, messageId, meta, originalTo) => {
-            this.handleIncomingMessage(from, payload, messageId, meta, originalTo);
-        };
     }
+    // =========================================================================
+    // Abstract method implementations (required by BaseWrapper)
+    // =========================================================================
+    /**
+     * Inject content into the PTY process.
+     * Used by BaseWrapper for message injection.
+     */
+    async performInjection(content) {
+        if (this.ptyProcess && this.running) {
+            this.ptyProcess.write(content);
+        }
+    }
+    /**
+     * Get cleaned output buffer for command parsing.
+     * Strips ANSI codes and returns raw buffer content.
+     */
+    getCleanOutput() {
+        return stripAnsi(this.rawBuffer);
+    }
+    // =========================================================================
+    // Lifecycle methods
+    // =========================================================================
     /**
      * Start the agent process
      */
@@ -188,16 +184,19 @@ export class PtyWrapper extends EventEmitter {
         }
         this.running = true;
         this.sessionStartTime = Date.now();
-        // Dispatch session start hook (handles trajectory initialization)
-        this.hookRegistry.dispatchSessionStart().catch(err => {
-            console.error(`[pty:${this.config.name}] Session start hook error:`, err);
-        });
-        // Initialize continuity and get agentId, then inject context
-        this.initializeAgentId()
-            .then(() => this.injectContinuityContext())
-            .catch(err => {
-            console.error(`[pty:${this.config.name}] Agent ID/continuity initialization error:`, err);
-        });
+        // Skip hooks and continuity in interactive mode - user handles all prompts directly
+        if (!this.config.interactive) {
+            // Dispatch session start hook (handles trajectory initialization)
+            this.hookRegistry.dispatchSessionStart().catch(err => {
+                console.error(`[pty:${this.config.name}] Session start hook error:`, err);
+            });
+            // Initialize continuity and get agentId, then inject context
+            this.initializeAgentId()
+                .then(() => this.injectContinuityContext())
+                .catch(err => {
+                console.error(`[pty:${this.config.name}] Agent ID/continuity initialization error:`, err);
+            });
+        }
         // Capture output
         this.ptyProcess.onData((data) => {
             this.handleOutput(data);
@@ -210,48 +209,19 @@ export class PtyWrapper extends EventEmitter {
             this.client.destroy();
         });
         // Inject initial instructions after a delay, then mark ready for messages
+        // Skip in interactive mode - user handles all prompts directly
         setTimeout(() => {
-            this.injectInstructions();
-            this.readyForMessages = true;
-            // Process any messages that arrived while waiting
-            this.processMessageQueue();
-        }, 2000);
-    }
-    /**
-     * Initialize agent ID for continuity/resume functionality
-     */
-    async initializeAgentId() {
-        if (!this.continuity)
-            return;
-        try {
-            let ledger;
-            // If resuming from a previous agent ID, try to find that ledger
-            if (this.config.resumeAgentId) {
-                ledger = await this.continuity.findLedgerByAgentId(this.config.resumeAgentId);
-                if (ledger) {
-                    console.log(`[pty:${this.config.name}] Resuming agent ID: ${ledger.agentId} (from previous session)`);
-                }
-                else {
-                    console.error(`[pty:${this.config.name}] Resume agent ID ${this.config.resumeAgentId} not found, creating new`);
-                }
+            if (!this.config.interactive) {
+                this.injectInstructions();
             }
-            // If not resuming or resume ID not found, get or create ledger
-            if (!ledger) {
-                ledger = await this.continuity.getOrCreateLedger(this.config.name, 'spawned');
-                console.log(`[pty:${this.config.name}] Agent ID: ${ledger.agentId} (use this to resume if agent dies)`);
+            this.readyForMessages = true;
+            // Process any messages that arrived while waiting (skip in interactive mode)
+            if (!this.config.interactive) {
+                this.processMessageQueue();
             }
-            this.agentId = ledger.agentId;
-        }
-        catch (err) {
-            console.error(`[pty:${this.config.name}] Failed to initialize agent ID: ${err.message}`);
-        }
-    }
-    /**
-     * Get the current agent ID
-     */
-    getAgentId() {
-        return this.agentId;
+        }, 2000);
     }
+    // Note: initializeAgentId() and getAgentId() are inherited from BaseWrapper
     /**
      * Inject continuity context from previous session.
      * Called after agent ID initialization to restore state from ledger.
@@ -310,6 +280,10 @@ export class PtyWrapper extends EventEmitter {
      *   ->continuity:uncertain "..."  - Mark item as uncertain
      *   ->continuity:handoff <<<...>>> - Create explicit handoff
      */
+    /**
+     * Parse continuity commands from output.
+     * Overrides BaseWrapper to use client.sendMessage instead of queuing.
+     */
     async parseContinuityCommands(content) {
         if (!this.continuity)
             return;
@@ -334,9 +308,7 @@ export class PtyWrapper extends EventEmitter {
             const response = await this.continuity.handleCommand(this.config.name, command);
             if (response) {
                 // Inject response via relay message to self
-                this.client.sendMessage(this.config.name, response, 'message', {
-                    thread: 'continuity-response',
-                });
+                this.client.sendMessage(this.config.name, response, 'message', undefined, 'continuity-response');
                 console.log(`[pty:${this.config.name}] Continuity command handled: ${command.type}`);
             }
         }
@@ -386,23 +358,31 @@ export class PtyWrapper extends EventEmitter {
         // Parse for relay commands
         this.parseRelayCommands();
         // Dispatch output hook (handles phase detection, etc.)
+        // Skip in interactive mode - no hooks should inject content
         const cleanData = stripAnsi(data);
-        this.hookRegistry.dispatchOutput(cleanData, data).catch(err => {
-            console.error(`[pty:${this.config.name}] Output hook error:`, err);
-        });
+        if (!this.config.interactive) {
+            this.hookRegistry.dispatchOutput(cleanData, data).catch(err => {
+                console.error(`[pty:${this.config.name}] Output hook error:`, err);
+            });
+        }
         // Check for [[SUMMARY]] and [[SESSION_END]] blocks and emit events
         // This allows cloud services to handle persistence without hardcoding storage
         const cleanContent = stripAnsi(this.rawBuffer);
         this.checkForSummaryAndEmit(cleanContent);
         this.checkForSessionEndAndEmit(cleanContent);
+        // Check for auth revocation patterns
+        this.checkAuthRevocation(cleanContent);
         // Parse for continuity commands (->continuity:save, ->continuity:load, etc.)
         // Use rawBuffer (accumulated content) not immediate chunk, since multi-line
         // fenced commands like ->continuity:save <<<...>>> span multiple output events
         // Optimization: Only parse new content with lookback for incomplete fenced commands
-        if (cleanContent.length > this.lastContinuityParsedLength) {
+        // Skip in interactive mode - no continuity features needed
+        if (!this.config.interactive && cleanContent.length > this.lastContinuityParsedLength) {
             const lookbackStart = Math.max(0, this.lastContinuityParsedLength - 500);
             const contentToParse = cleanContent.substring(lookbackStart);
-            this.parseContinuityCommands(contentToParse).catch(err => {
+            // Join continuation lines for multi-line fenced commands
+            const joinedContent = this.joinContinuationLines(contentToParse);
+            this.parseContinuityCommands(joinedContent).catch(err => {
                 console.error(`[pty:${this.config.name}] Continuity command parsing error:`, err);
             });
             this.lastContinuityParsedLength = cleanContent.length;
@@ -506,6 +486,9 @@ export class PtyWrapper extends EventEmitter {
     handleAutoAcceptPrompts(data) {
         if (!this.ptyProcess || !this.running)
             return;
+        // Skip auto-accept in interactive mode - user responds to prompts directly
+        if (this.config.interactive)
+            return;
         const cleanData = stripAnsi(data);
         // Check for the permission acceptance prompt (--dangerously-skip-permissions)
         // Pattern: "2. Yes, I accept" in the output
@@ -744,23 +727,17 @@ export class PtyWrapper extends EventEmitter {
         }
     }
     /**
-     * Send relay command to daemon
+     * Send relay command to daemon.
+     * Extends BaseWrapper to add PTY-specific logging and hook dispatch.
      */
     sendRelayCommand(cmd) {
-        const msgHash = `${cmd.to}:${cmd.body}`;
-        if (this.sentMessageHashes.has(msgHash)) {
-            console.log(`[pty:${this.config.name}] Skipping duplicate message to ${cmd.to}`);
-            return;
-        }
-        if (this.client.state !== 'READY') {
-            console.log(`[pty:${this.config.name}] Cannot send to ${cmd.to} - relay not ready (state: ${this.client.state})`);
-            return;
-        }
-        const success = this.client.sendMessage(cmd.to, cmd.body, cmd.kind, cmd.data, cmd.thread);
-        console.log(`[pty:${this.config.name}] Sent message to ${cmd.to}: ${success ? 'success' : 'failed'}`);
-        if (success) {
-            this.sentMessageHashes.add(msgHash);
-            // Dispatch message sent hook
+        // Check if this message would be sent (before BaseWrapper deduplicates)
+        const msgHash = `${cmd.to}:${cmd.body.substring(0, 100)}`;
+        const wouldSend = !this.sentMessageHashes.has(msgHash) && this.client.state === 'READY';
+        // Call base class to handle deduplication and actual send
+        super.sendRelayCommand(cmd);
+        // PTY-specific: Dispatch message sent hook if the message was sent
+        if (wouldSend && this.sentMessageHashes.has(msgHash)) {
             this.hookRegistry.dispatchMessageSent(cmd.to, cmd.body, cmd.thread).catch(err => {
                 console.error(`[pty:${this.config.name}] Message sent hook error:`, err);
             });
@@ -794,6 +771,8 @@ export class PtyWrapper extends EventEmitter {
      * - Command must be at start of line (after whitespace)
      * - Agent name must be PascalCase (e.g., Backend, Frontend, Worker1)
      * - CLI must be a known type (claude, codex, gemini, etc.)
+     *
+     * Overrides BaseWrapper to add PTY-specific validation and logging.
      */
     parseSpawnReleaseCommands(content) {
         // Need either API port or callbacks to handle spawn/release
@@ -968,7 +947,8 @@ export class PtyWrapper extends EventEmitter {
         }
     }
     /**
-     * Execute spawn via API or callback
+     * Execute spawn via API or callback.
+     * Overrides BaseWrapper to add PTY-specific logging and API path.
      */
     async executeSpawn(name, cli, task) {
         console.log(`[pty:${this.config.name}] [SPAWN-DEBUG] executeSpawn called: name=${name}, cli=${cli}, task="${task.substring(0, 50)}..."`);
@@ -1004,7 +984,8 @@ export class PtyWrapper extends EventEmitter {
         }
     }
     /**
-     * Execute release via API or callback
+     * Execute release via API or callback.
+     * Overrides BaseWrapper to add PTY-specific logging and API path.
      */
     async executeRelease(name) {
         if (this.config.dashboardPort) {
@@ -1036,25 +1017,15 @@ export class PtyWrapper extends EventEmitter {
         }
     }
     /**
-     * Handle incoming message from relay
-     * @param originalTo - The original 'to' field from sender. '*' indicates this was a broadcast message.
+     * Handle incoming message from relay.
+     * Extends BaseWrapper to add PTY-specific behavior.
      */
     handleIncomingMessage(from, payload, messageId, meta, originalTo) {
-        // Deduplicate: skip if we've already received this message
-        if (this.receivedMessageIds.has(messageId)) {
-            console.log(`[pty:${this.config.name}] Skipping duplicate message: ${messageId.substring(0, 8)}`);
-            return;
-        }
-        this.receivedMessageIds.add(messageId);
-        // Limit dedup set size to prevent memory leak
-        if (this.receivedMessageIds.size > 1000) {
-            const oldest = this.receivedMessageIds.values().next().value;
-            if (oldest)
-                this.receivedMessageIds.delete(oldest);
-        }
-        this.messageQueue.push({ from, body: payload.body, messageId, thread: payload.thread, importance: meta?.importance, data: payload.data, originalTo });
+        // Call base class to handle deduplication and queuing
+        super.handleIncomingMessage(from, payload, messageId, meta, originalTo);
+        // PTY-specific: Process the message queue immediately
         this.processMessageQueue();
-        // Dispatch message received hook
+        // PTY-specific: Dispatch message received hook
         this.hookRegistry.dispatchMessageReceived(from, payload.body, messageId).catch(err => {
             console.error(`[pty:${this.config.name}] Message received hook error:`, err);
         });
@@ -1323,12 +1294,6 @@ export class PtyWrapper extends EventEmitter {
             this.logStream = undefined;
         }
     }
-    get isRunning() {
-        return this.running;
-    }
-    get name() {
-        return this.config.name;
-    }
     get pid() {
         return this.ptyProcess?.pid;
     }
@@ -1340,6 +1305,9 @@ export class PtyWrapper extends EventEmitter {
      * Works with any CLI (Claude, Gemini, Codex, etc.)
      */
     trackOutputAndRemind(data) {
+        // Skip in interactive mode - user handles all prompts directly
+        if (this.config.interactive)
+            return;
         // Disabled if config.summaryReminder === false or env RELAY_SUMMARY_REMINDER_ENABLED=false
         if (this.config.summaryReminder === false)
             return;
@@ -1417,34 +1385,7 @@ export class PtyWrapper extends EventEmitter {
             summary,
         });
     }
-    /**
-     * Save a parsed summary to the continuity ledger.
-     * Maps summary fields to ledger fields for session recovery.
-     */
-    async saveSummaryToLedger(summary) {
-        if (!this.continuity)
-            return;
-        const updates = {};
-        // Map summary fields to ledger fields
-        if (summary.currentTask) {
-            updates.currentTask = summary.currentTask;
-        }
-        if (summary.completedTasks && summary.completedTasks.length > 0) {
-            updates.completed = summary.completedTasks;
-        }
-        if (summary.context) {
-            // Store context in inProgress as "next steps" hint
-            updates.inProgress = [summary.context];
-        }
-        if (summary.files && summary.files.length > 0) {
-            updates.fileContext = summary.files.map((f) => ({ path: f }));
-        }
-        // Only save if we have meaningful updates
-        if (Object.keys(updates).length > 0) {
-            await this.continuity.saveLedger(this.config.name, updates);
-            console.log(`[pty:${this.config.name}] Saved summary to continuity ledger`);
-        }
-    }
+    // Note: saveSummaryToLedger() is inherited from BaseWrapper
     /**
      * Check for [[SESSION_END]] blocks and emit 'session-end' event.
      * Allows cloud services to handle session closure without hardcoding storage.
@@ -1466,28 +1407,61 @@ export class PtyWrapper extends EventEmitter {
         });
     }
     /**
-     * Reset session-specific state for wrapper reuse.
-     * Call this when starting a new session with the same wrapper instance.
+     * Check for auth revocation patterns in output.
+     * Detects when the CLI's OAuth session has been revoked (e.g., user logged in elsewhere).
+     * Emits 'auth_revoked' event and sends notification to relay daemon.
      */
-    resetSessionState() {
-        this.sessionEndProcessed = false;
-        this.lastSummaryRawContent = '';
-        this.sessionEndData = undefined;
+    checkAuthRevocation(output) {
+        // Only check once - auth revocation is a terminal state
+        if (this.authRevoked)
+            return;
+        // Throttle checks to avoid performance impact
+        const now = Date.now();
+        if (now - this.lastAuthCheck < this.AUTH_CHECK_INTERVAL)
+            return;
+        this.lastAuthCheck = now;
+        // Determine provider from config
+        const provider = this.config.command || this.cliType || 'claude';
+        // Check for auth revocation patterns
+        const result = detectProviderAuthRevocation(output, provider);
+        if (result.detected && result.confidence !== 'low') {
+            this.authRevoked = true;
+            console.error(`[pty:${this.config.name}] Auth revocation detected: ` +
+                `pattern="${result.pattern}" confidence=${result.confidence} ` +
+                `message="${result.message}"`);
+            // Send notification to relay daemon via system channel
+            if (this.client.state === 'READY') {
+                const authPayload = JSON.stringify({
+                    type: 'auth_revoked',
+                    agent: this.config.name,
+                    provider,
+                    message: result.message,
+                    confidence: result.confidence,
+                    timestamp: new Date().toISOString(),
+                });
+                this.client.sendMessage('#system', authPayload, 'message');
+            }
+            // Emit event for external handlers (cloud services, dashboard)
+            this.emit('auth_revoked', {
+                agentName: this.config.name,
+                provider,
+                message: result.message,
+                confidence: result.confidence,
+            });
+        }
     }
     /**
-     * Get injection reliability metrics
+     * Reset auth state (e.g., after re-authentication)
      */
-    getInjectionMetrics() {
-        return {
-            ...this.injectionMetrics,
-            successRate: calculateSuccessRate(this.injectionMetrics),
-        };
+    resetAuthState() {
+        this.authRevoked = false;
+        this.lastAuthCheck = 0;
     }
     /**
-     * Get count of pending messages in queue
+     * Check if auth has been revoked
      */
-    get pendingMessageCount() {
-        return this.messageQueue.length;
+    isAuthRevoked() {
+        return this.authRevoked;
     }
 }
 //# sourceMappingURL=pty-wrapper.js.map