agent-relay 1.3.0 → 1.3.2

package/dist/wrapper/base-wrapper.d.ts

@@ -20,6 +20,7 @@ import type { ParsedCommand, ParsedSummary } from './parser.js';
 import type { SendPayload, SendMeta, SpeakOnTrigger } from '../protocol/types.js';
 import { type QueuedMessage, type InjectionMetrics, type CliType } from './shared.js';
 import { type ContinuityManager } from '../continuity/index.js';
+import { UniversalIdleDetector } from './idle-detector.js';
 /**
  * Base configuration shared by all wrapper types
  */
@@ -55,6 +56,10 @@ export interface BaseWrapperConfig {
     /** Shadow configuration */
     shadowOf?: string;
     shadowSpeakOn?: SpeakOnTrigger[];
+    /** Milliseconds of idle time before injection is allowed (default: 1500) */
+    idleBeforeInjectMs?: number;
+    /** Confidence threshold for idle detection (0-1, default: 0.7) */
+    idleConfidenceThreshold?: number;
 }
 /**
  * Abstract base class for agent wrappers
@@ -86,6 +91,7 @@ export declare abstract class BaseWrapper extends EventEmitter {
         completedTasks?: string[];
     };
     protected lastSummaryRawContent: string;
+    protected idleDetector: UniversalIdleDetector;
     constructor(config: BaseWrapperConfig);
     /** Start the agent process */
     abstract start(): Promise<void>;
@@ -102,6 +108,36 @@ export declare abstract class BaseWrapper extends EventEmitter {
         successRate: number;
     };
     get pendingMessageCount(): number;
+    /**
+     * Set the PID for process state inspection (Linux only).
+     * Call this after the agent process is started.
+     */
+    protected setIdleDetectorPid(pid: number): void;
+    /**
+     * Feed output to the idle detector.
+     * Call this whenever new output is received from the agent.
+     */
+    protected feedIdleDetectorOutput(output: string): void;
+    /**
+     * Check if the agent is idle and ready for injection.
+     * Returns idle state with confidence signals.
+     */
+    protected checkIdleForInjection(): {
+        isIdle: boolean;
+        confidence: number;
+        signals: Array<{
+            source: string;
+            confidence: number;
+        }>;
+    };
+    /**
+     * Wait for the agent to become idle.
+     * Returns when idle or after timeout.
+     */
+    protected waitForIdleState(timeoutMs?: number, pollMs?: number): Promise<{
+        isIdle: boolean;
+        confidence: number;
+    }>;
     /**
      * Handle incoming message from relay
      */

package/dist/wrapper/base-wrapper.js

@@ -18,7 +18,9 @@ import { EventEmitter } from 'node:events';
 import { RelayClient } from './client.js';
 import { isPlaceholderTarget } from './parser.js';
 import { getDefaultRelayPrefix, detectCliType, createInjectionMetrics, } from './shared.js';
+import { DEFAULT_IDLE_BEFORE_INJECT_MS, DEFAULT_IDLE_CONFIDENCE_THRESHOLD, } from '../config/relay-config.js';
 import { getContinuityManager, parseContinuityCommand, hasContinuityCommand, } from '../continuity/index.js';
+import { UniversalIdleDetector } from './idle-detector.js';
 /**
  * Abstract base class for agent wrappers
  */
@@ -45,6 +47,8 @@ export class BaseWrapper extends EventEmitter {
     sessionEndProcessed = false;
     sessionEndData;
     lastSummaryRawContent = '';
+    // Universal idle detection (shared across all wrapper types)
+    idleDetector;
     constructor(config) {
         super();
         this.config = config;
@@ -61,6 +65,11 @@ export class BaseWrapper extends EventEmitter {
         });
         // Initialize continuity manager
         this.continuity = getContinuityManager({ defaultCli: this.cliType });
+        // Initialize universal idle detector for robust injection timing
+        this.idleDetector = new UniversalIdleDetector({
+            minSilenceMs: config.idleBeforeInjectMs ?? DEFAULT_IDLE_BEFORE_INJECT_MS,
+            confidenceThreshold: config.idleConfidenceThreshold ?? DEFAULT_IDLE_CONFIDENCE_THRESHOLD,
+        });
         // Set up message handler
         this.client.onMessage = (from, payload, messageId, meta, originalTo) => {
             this.handleIncomingMessage(from, payload, messageId, meta, originalTo);
@@ -93,6 +102,39 @@ export class BaseWrapper extends EventEmitter {
         return this.messageQueue.length;
     }
     // =========================================================================
+    // Idle detection (shared across all wrapper types)
+    // =========================================================================
+    /**
+     * Set the PID for process state inspection (Linux only).
+     * Call this after the agent process is started.
+     */
+    setIdleDetectorPid(pid) {
+        this.idleDetector.setPid(pid);
+    }
+    /**
+     * Feed output to the idle detector.
+     * Call this whenever new output is received from the agent.
+     */
+    feedIdleDetectorOutput(output) {
+        this.idleDetector.onOutput(output);
+    }
+    /**
+     * Check if the agent is idle and ready for injection.
+     * Returns idle state with confidence signals.
+     */
+    checkIdleForInjection() {
+        return this.idleDetector.checkIdle({
+            minSilenceMs: this.config.idleBeforeInjectMs ?? 1500,
+        });
+    }
+    /**
+     * Wait for the agent to become idle.
+     * Returns when idle or after timeout.
+     */
+    async waitForIdleState(timeoutMs = 30000, pollMs = 200) {
+        return this.idleDetector.waitForIdle(timeoutMs, pollMs);
+    }
+    // =========================================================================
     // Message handling
     // =========================================================================
     /**
@@ -126,12 +168,16 @@ export class BaseWrapper extends EventEmitter {
      */
     sendRelayCommand(cmd) {
         // Validate target
-        if (isPlaceholderTarget(cmd.to))
+        if (isPlaceholderTarget(cmd.to)) {
+            console.error(`[base-wrapper] Skipped message - placeholder target: ${cmd.to}`);
             return;
+        }
         // Create hash for deduplication (use first 100 chars of body)
         const hash = `${cmd.to}:${cmd.body.substring(0, 100)}`;
-        if (this.sentMessageHashes.has(hash))
+        if (this.sentMessageHashes.has(hash)) {
+            console.error(`[base-wrapper] Skipped duplicate message to ${cmd.to}`);
             return;
+        }
         this.sentMessageHashes.add(hash);
         // Limit hash set size
         if (this.sentMessageHashes.size > 500) {

package/dist/wrapper/client.d.ts

@@ -1,6 +1,11 @@
 /**
  * Relay Client
  * Connects to the daemon and handles message sending/receiving.
+ *
+ * Optimizations:
+ * - Monotonic ID generation (faster than UUID)
+ * - Write coalescing (batch socket writes)
+ * - Circular dedup cache (O(1) eviction)
  */
 import { type SendPayload, type SendMeta, type PayloadKind, type SpeakOnTrigger, type EntityType } from '../protocol/types.js';
 export type ClientState = 'DISCONNECTED' | 'CONNECTING' | 'HANDSHAKING' | 'READY' | 'BACKOFF';
@@ -41,9 +46,9 @@ export declare class RelayClient {
     private reconnectDelay;
     private reconnectTimer?;
     private _destroyed;
-    private deliveredIds;
-    private deliveredOrder;
-    private readonly deliveredCacheLimit;
+    private dedupeCache;
+    private writeQueue;
+    private writeScheduled;
     /**
      * Handler for incoming messages.
      * @param from - The sender agent name
@@ -123,6 +128,10 @@ export declare class RelayClient {
     private setState;
     private sendHello;
     private send;
+    /**
+     * Flush all queued writes in a single syscall.
+     */
+    private flushWrites;
     private handleData;
     private processFrame;
     private handleWelcome;
@@ -133,7 +142,8 @@ export declare class RelayClient {
     private handleError;
     private scheduleReconnect;
     /**
-     * Track delivered message IDs to provide deterministic deduplication when messages are replayed.
+     * Check if message was already delivered (deduplication).
+     * Uses circular buffer for O(1) eviction.
      * @returns true if the message has already been seen.
      */
     private markDelivered;

package/dist/wrapper/client.js

@@ -1,11 +1,16 @@
 /**
  * Relay Client
  * Connects to the daemon and handles message sending/receiving.
+ *
+ * Optimizations:
+ * - Monotonic ID generation (faster than UUID)
+ * - Write coalescing (batch socket writes)
+ * - Circular dedup cache (O(1) eviction)
  */
 import net from 'node:net';
-import { v4 as uuid } from 'uuid';
+import { generateId } from '../utils/id-generator.js';
 import { PROTOCOL_VERSION, } from '../protocol/types.js';
-import { encodeFrame, FrameParser } from '../protocol/framing.js';
+import { encodeFrameLegacy, FrameParser } from '../protocol/framing.js';
 import { DEFAULT_SOCKET_PATH } from '../daemon/server.js';
 const DEFAULT_CLIENT_CONFIG = {
     socketPath: DEFAULT_SOCKET_PATH,
@@ -17,6 +22,40 @@ const DEFAULT_CLIENT_CONFIG = {
     reconnectDelayMs: 100,
     reconnectMaxDelayMs: 30000,
 };
+/**
+ * Circular buffer for O(1) deduplication with bounded memory.
+ */
+class CircularDedupeCache {
+    ids = new Set();
+    ring;
+    head = 0;
+    capacity;
+    constructor(capacity = 2000) {
+        this.capacity = capacity;
+        this.ring = new Array(capacity);
+    }
+    /** Returns true if duplicate (already seen) */
+    check(id) {
+        if (this.ids.has(id))
+            return true;
+        // Evict oldest if at capacity
+        if (this.ids.size >= this.capacity) {
+            const oldest = this.ring[this.head];
+            if (oldest)
+                this.ids.delete(oldest);
+        }
+        // Add new ID
+        this.ring[this.head] = id;
+        this.ids.add(id);
+        this.head = (this.head + 1) % this.capacity;
+        return false;
+    }
+    clear() {
+        this.ids.clear();
+        this.ring = new Array(this.capacity);
+        this.head = 0;
+    }
+}
 export class RelayClient {
     config;
     socket;
@@ -28,9 +67,11 @@ export class RelayClient {
     reconnectDelay;
     reconnectTimer;
     _destroyed = false;
-    deliveredIds = new Set();
-    deliveredOrder = [];
-    deliveredCacheLimit = 2000;
+    // Circular dedup cache (O(1) eviction vs O(n) array shift)
+    dedupeCache = new CircularDedupeCache(2000);
+    // Write coalescing: batch multiple writes into single syscall
+    writeQueue = [];
+    writeScheduled = false;
     // Event handlers
     /**
      * Handler for incoming messages.
@@ -46,6 +87,7 @@ export class RelayClient {
     constructor(config = {}) {
         this.config = { ...DEFAULT_CLIENT_CONFIG, ...config };
         this.parser = new FrameParser();
+        this.parser.setLegacyMode(true); // Use 4-byte header for backwards compatibility
         this.reconnectDelay = this.config.reconnectDelayMs;
     }
     get state() {
@@ -124,7 +166,7 @@ export class RelayClient {
             this.send({
                 v: PROTOCOL_VERSION,
                 type: 'BYE',
-                id: uuid(),
+                id: generateId(),
                 ts: Date.now(),
                 payload: {},
             });
@@ -156,7 +198,7 @@ export class RelayClient {
         const envelope = {
             v: PROTOCOL_VERSION,
             type: 'SEND',
-            id: uuid(),
+            id: generateId(),
             ts: Date.now(),
             to,
             payload: {
@@ -184,7 +226,7 @@ export class RelayClient {
         return this.send({
             v: PROTOCOL_VERSION,
             type: 'SUBSCRIBE',
-            id: uuid(),
+            id: generateId(),
             ts: Date.now(),
             topic,
             payload: {},
@@ -199,7 +241,7 @@ export class RelayClient {
         return this.send({
             v: PROTOCOL_VERSION,
             type: 'UNSUBSCRIBE',
-            id: uuid(),
+            id: generateId(),
             ts: Date.now(),
             topic,
             payload: {},
@@ -217,7 +259,7 @@ export class RelayClient {
         return this.send({
             v: PROTOCOL_VERSION,
             type: 'SHADOW_BIND',
-            id: uuid(),
+            id: generateId(),
             ts: Date.now(),
             payload: {
                 primaryAgent,
@@ -237,7 +279,7 @@ export class RelayClient {
         return this.send({
             v: PROTOCOL_VERSION,
             type: 'SHADOW_UNBIND',
-            id: uuid(),
+            id: generateId(),
             ts: Date.now(),
             payload: {
                 primaryAgent,
@@ -257,7 +299,7 @@ export class RelayClient {
         const envelope = {
             v: PROTOCOL_VERSION,
             type: 'LOG',
-            id: uuid(),
+            id: generateId(),
             ts: Date.now(),
             payload: {
                 data,
@@ -276,7 +318,7 @@ export class RelayClient {
         const hello = {
             v: PROTOCOL_VERSION,
             type: 'HELLO',
-            id: uuid(),
+            id: generateId(),
             ts: Date.now(),
             payload: {
                 agent: this.config.agentName,
@@ -303,8 +345,13 @@ export class RelayClient {
         if (!this.socket)
             return false;
         try {
-            const frame = encodeFrame(envelope);
-            this.socket.write(frame);
+            const frame = encodeFrameLegacy(envelope);
+            this.writeQueue.push(frame);
+            // Coalesce writes: schedule flush on next tick if not already scheduled
+            if (!this.writeScheduled) {
+                this.writeScheduled = true;
+                setImmediate(() => this.flushWrites());
+            }
             return true;
         }
         catch (err) {
@@ -312,6 +359,23 @@ export class RelayClient {
             return false;
         }
     }
+    /**
+     * Flush all queued writes in a single syscall.
+     */
+    flushWrites() {
+        this.writeScheduled = false;
+        if (this.writeQueue.length === 0 || !this.socket)
+            return;
+        if (this.writeQueue.length === 1) {
+            // Single frame - write directly (no concat needed)
+            this.socket.write(this.writeQueue[0]);
+        }
+        else {
+            // Multiple frames - batch into single write
+            this.socket.write(Buffer.concat(this.writeQueue));
+        }
+        this.writeQueue = [];
+    }
     handleData(data) {
         try {
             const frames = this.parser.push(data);
@@ -357,7 +421,7 @@ export class RelayClient {
         this.send({
             v: PROTOCOL_VERSION,
             type: 'ACK',
-            id: uuid(),
+            id: generateId(),
             ts: Date.now(),
             payload: {
                 ack_id: envelope.id,
@@ -378,7 +442,7 @@ export class RelayClient {
         this.send({
             v: PROTOCOL_VERSION,
             type: 'PONG',
-            id: uuid(),
+            id: generateId(),
             ts: Date.now(),
             payload: envelope.payload ?? {},
         });
@@ -435,23 +499,12 @@ export class RelayClient {
         }, delay);
     }
     /**
-     * Track delivered message IDs to provide deterministic deduplication when messages are replayed.
+     * Check if message was already delivered (deduplication).
+     * Uses circular buffer for O(1) eviction.
      * @returns true if the message has already been seen.
      */
     markDelivered(id) {
-        if (this.deliveredIds.has(id)) {
-            return true;
-        }
-        this.deliveredIds.add(id);
-        this.deliveredOrder.push(id);
-        // Simple FIFO eviction to keep memory bounded
-        if (this.deliveredOrder.length > this.deliveredCacheLimit) {
-            const oldest = this.deliveredOrder.shift();
-            if (oldest) {
-                this.deliveredIds.delete(oldest);
-            }
-        }
-        return false;
+        return this.dedupeCache.check(id);
     }
 }
 //# sourceMappingURL=client.js.map

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

@@ -0,0 +1,102 @@
+/**
+ * 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