agent-relay 1.6.0 → 2.0.4

package/dist/wrapper/idle-detector.d.ts

@@ -1,102 +0,0 @@
-/**
- * UniversalIdleDetector - Detect when an agent is waiting for input
- *
- * Works across all CLI tools (Claude, Codex, Gemini, Aider, etc.) by combining:
- * 1. Process state inspection via /proc/{pid}/stat (Linux, 95% confidence)
- * 2. Output silence analysis (cross-platform, 60-80% confidence)
- * 3. Natural ending detection (heuristic, 60% confidence)
- *
- * The hybrid approach ensures reliable idle detection regardless of CLI type.
- */
-export interface IdleSignal {
-    source: 'process_state' | 'output_silence' | 'natural_ending';
-    confidence: number;
-    timestamp: number;
-    details?: string;
-}
-export interface IdleResult {
-    isIdle: boolean;
-    confidence: number;
-    signals: IdleSignal[];
-}
-export interface IdleDetectorConfig {
-    /** Minimum silence duration to consider for idle (ms) */
-    minSilenceMs?: number;
-    /** Output buffer size limit */
-    bufferLimit?: number;
-    /** Confidence threshold for idle detection (0-1) */
-    confidenceThreshold?: number;
-}
-/**
- * Universal idle detector for any CLI-based agent.
- */
-export declare class UniversalIdleDetector {
-    private lastOutputTime;
-    private outputBuffer;
-    private pid;
-    private config;
-    constructor(config?: IdleDetectorConfig);
-    /**
-     * Set the PID of the agent process to monitor.
-     * Required for Linux process state inspection.
-     */
-    setPid(pid: number): void;
-    /**
-     * Get the current PID being monitored.
-     */
-    getPid(): number | null;
-    /**
-     * Process output chunk from the agent.
-     * Call this for every output received from the agent process.
-     */
-    onOutput(chunk: string): void;
-    /**
-     * Check if the agent process is blocked on read (waiting for input).
-     * This is the most reliable signal - the OS knows when a process is waiting.
-     *
-     * Linux-only; returns null on other platforms.
-     */
-    private isProcessWaitingForInput;
-    /**
-     * Get milliseconds since last output.
-     */
-    private getOutputSilenceMs;
-    /**
-     * Check if the last output ends "naturally" (complete thought vs mid-sentence).
-     * Helps distinguish between pauses in output and waiting for input.
-     */
-    private hasNaturalEnding;
-    /**
-     * Determine if the agent is idle and ready for input.
-     * Combines multiple signals for reliability across all CLI types.
-     */
-    checkIdle(options?: {
-        minSilenceMs?: number;
-    }): IdleResult;
-    /**
-     * Wait for idle state with timeout.
-     * Returns the idle result when achieved or after timeout.
-     */
-    waitForIdle(timeoutMs?: number, pollMs?: number): Promise<IdleResult>;
-    /**
-     * Reset state (call when agent starts new response).
-     */
-    reset(): void;
-    /**
-     * Get time since last output in milliseconds.
-     */
-    getTimeSinceLastOutput(): number;
-}
-/**
- * Get the PID of a process running in a tmux pane.
- * Uses tmux list-panes with format specifier.
- */
-export declare function getTmuxPanePid(tmuxPath: string, sessionName: string): Promise<number | null>;
-/**
- * Create an idle detector configured for the current platform.
- * Logs a warning on non-Linux platforms where process state inspection isn't available.
- */
-export declare function createIdleDetector(config?: IdleDetectorConfig, options?: {
-    quiet?: boolean;
-}): UniversalIdleDetector;
-//# sourceMappingURL=idle-detector.d.ts.map

package/dist/wrapper/idle-detector.js

@@ -1,279 +0,0 @@
-/**
- * UniversalIdleDetector - Detect when an agent is waiting for input
- *
- * Works across all CLI tools (Claude, Codex, Gemini, Aider, etc.) by combining:
- * 1. Process state inspection via /proc/{pid}/stat (Linux, 95% confidence)
- * 2. Output silence analysis (cross-platform, 60-80% confidence)
- * 3. Natural ending detection (heuristic, 60% confidence)
- *
- * The hybrid approach ensures reliable idle detection regardless of CLI type.
- */
-import fs from 'node:fs';
-const DEFAULT_CONFIG = {
-    minSilenceMs: 500,
-    bufferLimit: 10000,
-    confidenceThreshold: 0.7,
-};
-/**
- * Universal idle detector for any CLI-based agent.
- */
-export class UniversalIdleDetector {
-    lastOutputTime = 0;
-    outputBuffer = '';
-    pid = null;
-    config;
-    constructor(config = {}) {
-        this.config = { ...DEFAULT_CONFIG, ...config };
-        // Initialize lastOutputTime to now to avoid immediate false positives
-        this.lastOutputTime = Date.now();
-    }
-    /**
-     * Set the PID of the agent process to monitor.
-     * Required for Linux process state inspection.
-     */
-    setPid(pid) {
-        this.pid = pid;
-    }
-    /**
-     * Get the current PID being monitored.
-     */
-    getPid() {
-        return this.pid;
-    }
-    /**
-     * Process output chunk from the agent.
-     * Call this for every output received from the agent process.
-     */
-    onOutput(chunk) {
-        this.lastOutputTime = Date.now();
-        this.outputBuffer += chunk;
-        // Keep buffer bounded
-        if (this.outputBuffer.length > this.config.bufferLimit) {
-            this.outputBuffer = this.outputBuffer.slice(-Math.floor(this.config.bufferLimit / 2));
-        }
-    }
-    /**
-     * Check if the agent process is blocked on read (waiting for input).
-     * This is the most reliable signal - the OS knows when a process is waiting.
-     *
-     * Linux-only; returns null on other platforms.
-     */
-    isProcessWaitingForInput() {
-        if (process.platform !== 'linux' || !this.pid) {
-            return null; // Can't determine on non-Linux
-        }
-        try {
-            // Check process state from /proc/{pid}/stat
-            // State codes: R=running, S=sleeping, D=disk sleep, Z=zombie, T=stopped
-            const statPath = `/proc/${this.pid}/stat`;
-            const stat = fs.readFileSync(statPath, 'utf-8');
-            const fields = stat.split(' ');
-            const state = fields[2]; // Third field is state
-            // S (sleeping) often means waiting for I/O
-            if (state !== 'S') {
-                return { waiting: false }; // Running or other state = not waiting
-            }
-            // More precise: check what the process is blocked on
-            const wchanPath = `/proc/${this.pid}/wchan`;
-            const wchan = fs.readFileSync(wchanPath, 'utf-8').trim();
-            // Common wait channels for terminal input
-            const inputWaitChannels = [
-                'wait_woken',
-                'poll_schedule_timeout',
-                'do_select',
-                'n_tty_read',
-                'unix_stream_read_generic',
-                'pipe_read',
-                'ep_poll', // epoll wait
-                'futex_wait_queue', // sometimes seen
-            ];
-            const isWaiting = inputWaitChannels.some(ch => wchan.includes(ch));
-            return { waiting: isWaiting, wchan };
-        }
-        catch {
-            return null; // Process may have exited or permission denied
-        }
-    }
-    /**
-     * Get milliseconds since last output.
-     */
-    getOutputSilenceMs() {
-        return Date.now() - this.lastOutputTime;
-    }
-    /**
-     * Check if the last output ends "naturally" (complete thought vs mid-sentence).
-     * Helps distinguish between pauses in output and waiting for input.
-     */
-    hasNaturalEnding() {
-        const lastChars = this.outputBuffer.slice(-100).trim();
-        if (lastChars.length === 0)
-            return true;
-        // Positive signals: output ended cleanly
-        const naturalEndings = [
-            /[.!?]\s*$/, // Sentence ended
-            /```\s*$/, // Code block closed
-            /\n\n$/, // Paragraph break
-            />\s*$/, // Prompt character
-            /\$\s*$/, // Shell prompt
-            />>>\s*$/, // Python/Aider prompt
-            /❯\s*$/, // Fancy prompts
-            /λ\s*$/, // Lambda prompts
-            /→\s*$/, // Arrow prompts
-        ];
-        // Negative signals: output mid-thought
-        const midThought = [
-            /[,;:]\s*$/, // Comma, semicolon = more coming
-            /\w$/, // Ended mid-word (no trailing space)
-            /[-–—]\s*$/, // Dash = continuation
-            /\(\s*$/, // Open paren
-            /\[\s*$/, // Open bracket
-            /\{\s*$/, // Open brace
-            /\\\s*$/, // Line continuation
-        ];
-        for (const pattern of midThought) {
-            if (pattern.test(lastChars)) {
-                return false;
-            }
-        }
-        for (const pattern of naturalEndings) {
-            if (pattern.test(lastChars)) {
-                return true;
-            }
-        }
-        // Default: assume natural if no negative signals and some silence
-        return true;
-    }
-    /**
-     * Determine if the agent is idle and ready for input.
-     * Combines multiple signals for reliability across all CLI types.
-     */
-    checkIdle(options = {}) {
-        const minSilence = options.minSilenceMs ?? this.config.minSilenceMs;
-        const signals = [];
-        // Signal 1: Process state (most reliable on Linux)
-        const processState = this.isProcessWaitingForInput();
-        if (processState !== null) {
-            if (processState.waiting) {
-                signals.push({
-                    source: 'process_state',
-                    confidence: 0.95, // Very high - OS-level truth
-                    timestamp: Date.now(),
-                    details: processState.wchan,
-                });
-            }
-            else {
-                // Process is actively running - definitely not idle
-                return {
-                    isIdle: false,
-                    confidence: 0.95,
-                    signals: [{
-                            source: 'process_state',
-                            confidence: 0.95,
-                            timestamp: Date.now(),
-                            details: 'process running',
-                        }],
-                };
-            }
-        }
-        // processState === null means we can't determine (non-Linux)
-        // Signal 2: Output silence
-        const silenceMs = this.getOutputSilenceMs();
-        if (silenceMs > minSilence) {
-            // Confidence scales with silence duration (up to 0.8)
-            // 500ms = 0.13, 1000ms = 0.27, 2000ms = 0.53, 3000ms = 0.8
-            const silenceConfidence = Math.min(silenceMs / 3000, 0.8);
-            signals.push({
-                source: 'output_silence',
-                confidence: silenceConfidence,
-                timestamp: Date.now(),
-                details: `${silenceMs}ms`,
-            });
-        }
-        // Signal 3: Natural ending (only if some silence)
-        if (silenceMs > 200 && this.hasNaturalEnding()) {
-            signals.push({
-                source: 'natural_ending',
-                confidence: 0.6,
-                timestamp: Date.now(),
-            });
-        }
-        // No signals = not idle
-        if (signals.length === 0) {
-            return { isIdle: false, confidence: 0, signals: [] };
-        }
-        // Combine signals
-        // Use max confidence, boosted if multiple signals agree
-        const maxConfidence = Math.max(...signals.map(s => s.confidence));
-        const boost = signals.length > 1 ? 0.1 : 0;
-        const combinedConfidence = Math.min(maxConfidence + boost, 1.0);
-        return {
-            isIdle: combinedConfidence >= this.config.confidenceThreshold,
-            confidence: combinedConfidence,
-            signals,
-        };
-    }
-    /**
-     * Wait for idle state with timeout.
-     * Returns the idle result when achieved or after timeout.
-     */
-    async waitForIdle(timeoutMs = 30000, pollMs = 200) {
-        const startTime = Date.now();
-        while (Date.now() - startTime < timeoutMs) {
-            const result = this.checkIdle();
-            if (result.isIdle) {
-                return result;
-            }
-            await new Promise(r => setTimeout(r, pollMs));
-        }
-        // Timeout - return current state
-        return this.checkIdle();
-    }
-    /**
-     * Reset state (call when agent starts new response).
-     */
-    reset() {
-        this.outputBuffer = '';
-        this.lastOutputTime = Date.now();
-    }
-    /**
-     * Get time since last output in milliseconds.
-     */
-    getTimeSinceLastOutput() {
-        return this.getOutputSilenceMs();
-    }
-}
-/**
- * Get the PID of a process running in a tmux pane.
- * Uses tmux list-panes with format specifier.
- */
-export async function getTmuxPanePid(tmuxPath, sessionName) {
-    const { exec } = await import('node:child_process');
-    const { promisify } = await import('node:util');
-    const execAsync = promisify(exec);
-    try {
-        // Get the PID of the command running in the pane
-        const { stdout } = await execAsync(`"${tmuxPath}" list-panes -t ${sessionName} -F "#{pane_pid}" 2>/dev/null`);
-        const pid = parseInt(stdout.trim(), 10);
-        return isNaN(pid) ? null : pid;
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * Create an idle detector configured for the current platform.
- * Logs a warning on non-Linux platforms where process state inspection isn't available.
- */
-export function createIdleDetector(config = {}, options = {}) {
-    const detector = new UniversalIdleDetector(config);
-    if (!options.quiet) {
-        if (process.platform === 'darwin') {
-            console.warn('[idle-detector] macOS: using output analysis only (less reliable)');
-        }
-        else if (process.platform === 'win32') {
-            console.warn('[idle-detector] Windows: using output analysis only (less reliable)');
-        }
-    }
-    return detector;
-}
-//# sourceMappingURL=idle-detector.js.map

package/dist/wrapper/index.d.ts

@@ -1,4 +0,0 @@
-export * from './client.js';
-export * from './parser.js';
-export * from './base-wrapper.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/wrapper/index.js

@@ -1,7 +0,0 @@
-export * from './client.js';
-export * from './parser.js';
-export * from './base-wrapper.js';
-// Note: tmux-wrapper.ts and pty-wrapper.ts are intentionally not exported here.
-// They're dynamically imported in CLI only, as they have different
-// runtime requirements (tmux/pty must be available).
-//# sourceMappingURL=index.js.map

package/dist/wrapper/parser.d.ts

@@ -1,230 +0,0 @@
-/**
- * PTY Output Parser
- * Extracts relay commands from agent terminal output.
- *
- * Supports two formats:
- * 1. Inline: ->relay:<target> <message> (single line, start of line only)
- * 2. Block: [[RELAY]]{ json }[[/RELAY]] (multi-line, structured)
- *
- * Rules:
- * - Inline only matches at start of line (after whitespace)
- * - Ignores content inside code fences
- * - Escape with \->relay: to output literal
- * - Block format is preferred for structured data
- */
-import type { PayloadKind } from '../protocol/types.js';
-export interface ParsedCommand {
-    to: string;
-    kind: PayloadKind;
-    body: string;
-    data?: Record<string, unknown>;
-    /** Optional thread ID for grouping related messages */
-    thread?: string;
-    /** Optional project for cross-project messaging (e.g., ->relay:project:agent) */
-    project?: string;
-    /** Optional thread project for cross-project threads (e.g., [thread:project:id]) */
-    threadProject?: string;
-    raw: string;
-    meta?: ParsedMessageMetadata;
-}
-export interface ParserOptions {
-    maxBlockBytes?: number;
-    enableInline?: boolean;
-    enableBlock?: boolean;
-    /** Relay prefix pattern (default: '->relay:') */
-    prefix?: string;
-    /** Thinking prefix pattern (default: '->thinking:') */
-    thinkingPrefix?: string;
-}
-/**
- * Check if a target name is a placeholder commonly used in documentation/examples.
- * These should not be treated as real message targets.
- */
-export declare function isPlaceholderTarget(target: string): boolean;
-export declare class OutputParser {
-    private options;
-    private inCodeFence;
-    private inBlock;
-    private blockBuffer;
-    private blockType;
-    private lastParsedMetadata;
-    private inThinkingBlock;
-    private inFencedInline;
-    private fencedInlineBuffer;
-    private fencedInlineTarget;
-    private fencedInlineThread;
-    private fencedInlineThreadProject;
-    private fencedInlineProject;
-    private fencedInlineRaw;
-    private fencedInlineKind;
-    private inlineRelayPattern;
-    private inlineThinkingPattern;
-    private fencedRelayPattern;
-    private fencedThinkingPattern;
-    private escapePattern;
-    constructor(options?: ParserOptions);
-    /**
-     * Get the configured relay prefix
-     */
-    get prefix(): string;
-    /**
-     * Push data into the parser and extract commands.
-     * Returns array of parsed commands and cleaned output.
-     *
-     * Design: Pass through data with minimal buffering to preserve terminal rendering.
-     * Only buffer content when inside [[RELAY]]...[[/RELAY]] blocks.
-     */
-    parse(data: string): {
-        commands: ParsedCommand[];
-        output: string;
-    };
-    /**
-     * Find [[RELAY_METADATA]] or [[RELAY]] that's at the start of a line and not inside a code fence.
-     * Returns the index and identifier, or -1 and null if not found.
-     */
-    private findBlockStart;
-    /**
-     * Parse data in pass-through mode - TRUE pass-through for terminal rendering.
-     * Output is exactly the input data, minus any relay command lines found in this chunk.
-     * No cross-chunk buffering to avoid double-output issues.
-     *
-     * IMPORTANT: We ONLY parse complete lines (i.e. those terminated by `\n` in the
-     * current chunk). The final unterminated line (if any) is passed through without
-     * parsing. This intentionally avoids cross-chunk detection when a line is split
-     * across chunks.
-     */
-    private parsePassThrough;
-    /**
-     * Parse while inside a [[RELAY]] block - buffer until we see [[/RELAY]].
-     */
-    private parseInBlockMode;
-    /**
-     * Process a single complete line for inline relay commands.
-     * Block handling is done at the parse() level, not here.
-     *
-     * IMPORTANT: We strip ANSI codes for pattern matching, but preserve
-     * the original line for output to maintain terminal rendering.
-     *
-     * OPTIMIZATION: Early exit for lines that can't possibly be relay commands.
-     * Most lines don't contain relay patterns, so we avoid expensive regex/ANSI
-     * stripping for the common case.
-     */
-    private processLine;
-    /**
-     * Finish processing a block and extract command.
-     * Returns the command (if valid) and any remaining content after [[/RELAY]].
-     */
-    private finishBlock;
-    /**
-     * Check if the current fenced inline command should be filtered out.
-     * Returns true if the command looks like instructional/example text.
-     */
-    private shouldFilterFencedInline;
-    /**
-     * Parse while inside a fenced inline block (->relay:Target <<< ... >>>).
-     * Accumulates lines until >>> is seen on its own line.
-     */
-    private parseFencedInlineMode;
-    /**
-     * Flush any remaining buffer (call on stream end).
-     */
-    flush(): {
-        commands: ParsedCommand[];
-        output: string;
-    };
-    /**
-     * Reset parser state.
-     */
-    reset(): void;
-}
-/**
- * Parsed message metadata block from agent output.
- */
-export interface ParsedMessageMetadata {
-    subject?: string;
-    importance?: number;
-    replyTo?: string;
-    ackRequired?: boolean;
-}
-/**
- * Result of attempting to parse a RELAY_METADATA block.
- */
-export interface MetadataParseResult {
-    found: boolean;
-    valid: boolean;
-    metadata: ParsedMessageMetadata | null;
-    rawContent: string | null;
-}
-/**
- * Parse [[RELAY_METADATA]]...[[/RELAY_METADATA]] blocks from agent output.
- * Agents can output metadata to enhance messages.
- *
- * Format:
- * [[RELAY_METADATA]]
- * {
- *   "subject": "Task update",
- *   "importance": 80,
- *   "replyTo": "msg-abc123",
- *   "ackRequired": true
- * }
- * [[/RELAY_METADATA]]
- */
-export declare function parseRelayMetadataFromOutput(output: string): MetadataParseResult;
-/**
- * Parsed summary block from agent output.
- */
-export interface ParsedSummary {
-    currentTask?: string;
-    completedTasks?: string[];
-    decisions?: string[];
-    context?: string;
-    files?: string[];
-}
-/**
- * Result of attempting to parse a SUMMARY block.
- */
-export interface SummaryParseResult {
-    found: boolean;
-    valid: boolean;
-    summary: ParsedSummary | null;
-    rawContent: string | null;
-}
-/**
- * Parse [[SUMMARY]]...[[/SUMMARY]] blocks from agent output.
- * Agents can output summaries to keep a running context of their work.
- *
- * Format:
- * [[SUMMARY]]
- * {
- *   "currentTask": "Working on auth module",
- *   "context": "Completed login flow, now implementing logout",
- *   "files": ["src/auth.ts", "src/session.ts"]
- * }
- * [[/SUMMARY]]
- */
-export declare function parseSummaryFromOutput(output: string): ParsedSummary | null;
-/**
- * Parse SUMMARY block with full details for deduplication.
- * Returns raw content to allow caller to dedupe before logging errors.
- */
-export declare function parseSummaryWithDetails(output: string): SummaryParseResult;
-/**
- * Session end marker from agent output.
- */
-export interface SessionEndMarker {
-    summary?: string;
-    completedTasks?: string[];
-}
-/**
- * Parse [[SESSION_END]]...[[/SESSION_END]] blocks from agent output.
- * Agents output this to explicitly mark their session as complete.
- *
- * Format:
- * [[SESSION_END]]
- * {"summary": "Completed auth module implementation", "completedTasks": ["login", "logout"]}
- * [[/SESSION_END]]
- *
- * Or simply: [[SESSION_END]][[/SESSION_END]] for a clean close without summary.
- */
-export declare function parseSessionEndFromOutput(output: string): SessionEndMarker | null;
-//# sourceMappingURL=parser.d.ts.map