agent-relay 1.6.0 → 2.0.4

package/dist/bridge/multi-project-client.d.ts

@@ -1,99 +0,0 @@
-/**
- * MultiProjectClient
- * Connects to multiple project daemons simultaneously for cross-project orchestration.
- */
-import { type SendPayload } from '../protocol/types.js';
-import type { ProjectConfig } from './types.js';
-interface MultiProjectClientOptions {
-    /** Agent name to register as (default: '__BridgeClient'). Must be unique per daemon. */
-    agentName?: string;
-    /** Enable automatic reconnection on disconnect (default: true) */
-    reconnect?: boolean;
-    /** Initial reconnection delay in ms (default: 1000) */
-    reconnectDelay?: number;
-    /** Maximum reconnection delay in ms (default: 30000) */
-    maxReconnectDelay?: number;
-    /** Maximum reconnection attempts before giving up (default: Infinity) */
-    maxReconnectAttempts?: number;
-}
-export declare class MultiProjectClient {
-    private projects;
-    private connections;
-    private leads;
-    private options;
-    private shuttingDown;
-    /** Handler for incoming messages */
-    onMessage?: (projectId: string, from: string, payload: SendPayload, messageId: string) => void;
-    /** Handler for connection state changes */
-    onProjectStateChange?: (projectId: string, connected: boolean) => void;
-    constructor(projects: ProjectConfig[], options?: MultiProjectClientOptions);
-    /**
-     * Connect to all project daemons
-     */
-    connect(): Promise<void>;
-    /**
-     * Connect to a single project daemon
-     */
-    private connectToProject;
-    /**
-     * Send HELLO to a project daemon
-     */
-    private sendHello;
-    /**
-     * Handle incoming data from a project connection
-     */
-    private handleData;
-    /**
-     * Process a frame from a project daemon
-     */
-    private processFrame;
-    /**
-     * Handle delivered message from a project
-     */
-    private handleDeliver;
-    /**
-     * Send envelope to a project daemon
-     */
-    private send;
-    /**
-     * Send message to a project
-     * @param projectId - Target project ID
-     * @param to - Agent name within the project (or '*' for broadcast, 'lead' for project lead)
-     * @param body - Message body
-     */
-    sendToProject(projectId: string, to: string, body: string): boolean;
-    /**
-     * Broadcast to all leads
-     */
-    broadcastToLeads(body: string): void;
-    /**
-     * Broadcast to all agents in all projects
-     */
-    broadcastAll(body: string): void;
-    /**
-     * Register a lead for a project
-     */
-    registerLead(projectId: string, leadName: string): void;
-    /**
-     * Get all connected projects
-     */
-    getConnectedProjects(): string[];
-    /**
-     * Get project connection info
-     */
-    getProject(projectId: string): ProjectConfig | undefined;
-    /**
-     * Schedule a reconnection attempt with exponential backoff
-     */
-    private scheduleReconnect;
-    /**
-     * Attempt to reconnect to a project daemon
-     */
-    private attemptReconnect;
-    /**
-     * Disconnect from all projects
-     */
-    disconnect(): void;
-}
-export {};
-//# sourceMappingURL=multi-project-client.d.ts.map

package/dist/bridge/multi-project-client.js

@@ -1,389 +0,0 @@
-/**
- * MultiProjectClient
- * Connects to multiple project daemons simultaneously for cross-project orchestration.
- */
-import net from 'node:net';
-import fs from 'node:fs';
-import { generateId } from '../utils/id-generator.js';
-import { PROTOCOL_VERSION, } from '../protocol/types.js';
-import { encodeFrameLegacy as encodeFrame, FrameParser } from '../protocol/framing.js';
-export class MultiProjectClient {
-    projects;
-    connections = new Map();
-    leads = new Map();
-    options;
-    shuttingDown = false;
-    /** Handler for incoming messages */
-    onMessage;
-    /** Handler for connection state changes */
-    onProjectStateChange;
-    constructor(projects, options = {}) {
-        this.projects = projects;
-        this.options = {
-            agentName: options.agentName ?? '__BridgeClient',
-            reconnect: options.reconnect ?? true,
-            reconnectDelay: options.reconnectDelay ?? 1000,
-            maxReconnectDelay: options.maxReconnectDelay ?? 30000,
-            maxReconnectAttempts: options.maxReconnectAttempts ?? Infinity,
-        };
-    }
-    /**
-     * Connect to all project daemons
-     */
-    async connect() {
-        const connectPromises = this.projects.map((project) => this.connectToProject(project));
-        await Promise.all(connectPromises);
-    }
-    /**
-     * Connect to a single project daemon
-     */
-    connectToProject(project) {
-        return new Promise((resolve, reject) => {
-            // Check socket exists
-            if (!fs.existsSync(project.socketPath)) {
-                console.error(`[bridge] No daemon running for ${project.id} (${project.path})`);
-                console.error(`[bridge] Start with: cd ${project.path} && agent-relay up`);
-                reject(new Error(`No daemon for ${project.id}`));
-                return;
-            }
-            const socket = net.createConnection(project.socketPath, () => {
-                this.sendHello(conn);
-            });
-            const parser = new FrameParser();
-            parser.setLegacyMode(true); // Use 4-byte header for backwards compatibility
-            const conn = {
-                config: project,
-                socket,
-                parser,
-                ready: false,
-            };
-            socket.on('data', (data) => this.handleData(conn, data));
-            socket.on('close', () => {
-                const wasReady = conn.ready;
-                conn.ready = false;
-                this.onProjectStateChange?.(project.id, false);
-                // Attempt reconnection if enabled and not shutting down
-                if (wasReady && this.options.reconnect && !this.shuttingDown) {
-                    this.scheduleReconnect(conn);
-                }
-            });
-            socket.on('error', (err) => {
-                console.error(`[bridge] Connection error for ${project.id}:`, err.message);
-                if (!conn.ready) {
-                    reject(err);
-                }
-            });
-            this.connections.set(project.id, conn);
-            // Wait for ready
-            const checkReady = setInterval(() => {
-                if (conn.ready) {
-                    clearInterval(checkReady);
-                    clearTimeout(timeout);
-                    resolve();
-                }
-            }, 10);
-            const timeout = setTimeout(() => {
-                if (!conn.ready) {
-                    clearInterval(checkReady);
-                    socket.destroy();
-                    reject(new Error(`Connection timeout for ${project.id}`));
-                }
-            }, 5000);
-        });
-    }
-    /**
-     * Send HELLO to a project daemon
-     */
-    sendHello(conn) {
-        const hello = {
-            v: PROTOCOL_VERSION,
-            type: 'HELLO',
-            id: generateId(),
-            ts: Date.now(),
-            payload: {
-                agent: this.options.agentName,
-                cli: 'bridge',
-                capabilities: {
-                    ack: true,
-                    resume: false,
-                    max_inflight: 256,
-                    supports_topics: true,
-                },
-            },
-        };
-        this.send(conn, hello);
-    }
-    /**
-     * Handle incoming data from a project connection
-     */
-    handleData(conn, data) {
-        try {
-            const frames = conn.parser.push(data);
-            for (const frame of frames) {
-                this.processFrame(conn, frame);
-            }
-        }
-        catch (err) {
-            console.error(`[bridge] Parse error for ${conn.config.id}:`, err);
-        }
-    }
-    /**
-     * Process a frame from a project daemon
-     */
-    processFrame(conn, envelope) {
-        switch (envelope.type) {
-            case 'WELCOME':
-                conn.ready = true;
-                console.log(`[bridge] Connected to ${conn.config.id}`);
-                this.onProjectStateChange?.(conn.config.id, true);
-                break;
-            case 'DELIVER':
-                this.handleDeliver(conn, envelope);
-                break;
-            case 'PING':
-                this.send(conn, {
-                    v: PROTOCOL_VERSION,
-                    type: 'PONG',
-                    id: generateId(),
-                    ts: Date.now(),
-                    payload: envelope.payload ?? {},
-                });
-                break;
-        }
-    }
-    /**
-     * Handle delivered message from a project
-     */
-    handleDeliver(conn, envelope) {
-        // Send ACK
-        this.send(conn, {
-            v: PROTOCOL_VERSION,
-            type: 'ACK',
-            id: generateId(),
-            ts: Date.now(),
-            payload: {
-                ack_id: envelope.id,
-                seq: envelope.delivery.seq,
-            },
-        });
-        // Notify handler
-        if (this.onMessage && envelope.from) {
-            this.onMessage(conn.config.id, envelope.from, envelope.payload, envelope.id);
-        }
-    }
-    /**
-     * Send envelope to a project daemon
-     */
-    send(conn, envelope) {
-        if (!conn.socket)
-            return false;
-        try {
-            const frame = encodeFrame(envelope);
-            conn.socket.write(frame);
-            return true;
-        }
-        catch (err) {
-            console.error(`[bridge] Send error for ${conn.config.id}:`, err);
-            return false;
-        }
-    }
-    /**
-     * Send message to a project
-     * @param projectId - Target project ID
-     * @param to - Agent name within the project (or '*' for broadcast, 'lead' for project lead)
-     * @param body - Message body
-     */
-    sendToProject(projectId, to, body) {
-        const conn = this.connections.get(projectId);
-        if (!conn?.ready) {
-            console.error(`[bridge] Cannot send to ${projectId}: not connected`);
-            return false;
-        }
-        // Resolve 'lead' to actual lead name
-        let targetAgent = to;
-        if (to === 'lead') {
-            const lead = this.leads.get(projectId);
-            if (lead) {
-                targetAgent = lead.name;
-            }
-            else {
-                // Fallback to configured lead name
-                targetAgent = conn.config.leadName;
-            }
-        }
-        const envelope = {
-            v: PROTOCOL_VERSION,
-            type: 'SEND',
-            id: generateId(),
-            ts: Date.now(),
-            to: targetAgent,
-            payload: {
-                kind: 'message',
-                body,
-            },
-        };
-        return this.send(conn, envelope);
-    }
-    /**
-     * Broadcast to all leads
-     */
-    broadcastToLeads(body) {
-        for (const [projectId] of this.connections) {
-            this.sendToProject(projectId, 'lead', body);
-        }
-    }
-    /**
-     * Broadcast to all agents in all projects
-     */
-    broadcastAll(body) {
-        for (const [_projectId, conn] of this.connections) {
-            if (conn.ready) {
-                const envelope = {
-                    v: PROTOCOL_VERSION,
-                    type: 'SEND',
-                    id: generateId(),
-                    ts: Date.now(),
-                    to: '*',
-                    payload: {
-                        kind: 'message',
-                        body,
-                    },
-                };
-                this.send(conn, envelope);
-            }
-        }
-    }
-    /**
-     * Register a lead for a project
-     */
-    registerLead(projectId, leadName) {
-        this.leads.set(projectId, {
-            name: leadName,
-            projectId,
-            connected: true,
-        });
-    }
-    /**
-     * Get all connected projects
-     */
-    getConnectedProjects() {
-        return Array.from(this.connections.entries())
-            .filter(([_, conn]) => conn.ready)
-            .map(([id]) => id);
-    }
-    /**
-     * Get project connection info
-     */
-    getProject(projectId) {
-        return this.connections.get(projectId)?.config;
-    }
-    /**
-     * Schedule a reconnection attempt with exponential backoff
-     */
-    scheduleReconnect(conn) {
-        if (conn.reconnecting || this.shuttingDown)
-            return;
-        const attempts = conn.reconnectAttempts ?? 0;
-        if (attempts >= this.options.maxReconnectAttempts) {
-            console.error(`[bridge] Max reconnection attempts reached for ${conn.config.id}`);
-            return;
-        }
-        conn.reconnecting = true;
-        conn.reconnectAttempts = attempts + 1;
-        // Calculate delay with exponential backoff
-        const delay = Math.min(this.options.reconnectDelay * Math.pow(2, attempts), this.options.maxReconnectDelay);
-        console.log(`[bridge] Reconnecting to ${conn.config.id} in ${delay}ms (attempt ${conn.reconnectAttempts})`);
-        conn.reconnectTimer = setTimeout(() => {
-            this.attemptReconnect(conn);
-        }, delay);
-    }
-    /**
-     * Attempt to reconnect to a project daemon
-     */
-    attemptReconnect(conn) {
-        if (this.shuttingDown) {
-            conn.reconnecting = false;
-            return;
-        }
-        // Check socket exists
-        if (!fs.existsSync(conn.config.socketPath)) {
-            console.error(`[bridge] No daemon running for ${conn.config.id}, will retry`);
-            conn.reconnecting = false;
-            this.scheduleReconnect(conn);
-            return;
-        }
-        const socket = net.createConnection(conn.config.socketPath, () => {
-            this.sendHello(conn);
-        });
-        // Update connection with new socket and fresh parser
-        conn.socket = socket;
-        conn.parser = new FrameParser();
-        conn.parser.setLegacyMode(true); // Use 4-byte header for backwards compatibility
-        socket.on('data', (data) => this.handleData(conn, data));
-        socket.on('close', () => {
-            const wasReady = conn.ready;
-            conn.ready = false;
-            this.onProjectStateChange?.(conn.config.id, false);
-            if (wasReady && this.options.reconnect && !this.shuttingDown) {
-                this.scheduleReconnect(conn);
-            }
-        });
-        socket.on('error', (err) => {
-            console.error(`[bridge] Reconnection error for ${conn.config.id}:`, err.message);
-            conn.reconnecting = false;
-            if (!this.shuttingDown) {
-                this.scheduleReconnect(conn);
-            }
-        });
-        // Reset reconnection state on successful connect
-        const originalReady = conn.ready;
-        const checkReady = setInterval(() => {
-            if (conn.ready && !originalReady) {
-                clearInterval(checkReady);
-                clearTimeout(timeout);
-                conn.reconnecting = false;
-                conn.reconnectAttempts = 0;
-                console.log(`[bridge] Reconnected to ${conn.config.id}`);
-            }
-        }, 10);
-        const timeout = setTimeout(() => {
-            if (!conn.ready) {
-                clearInterval(checkReady);
-                socket.destroy();
-                conn.reconnecting = false;
-                console.error(`[bridge] Reconnection timeout for ${conn.config.id}`);
-                if (!this.shuttingDown) {
-                    this.scheduleReconnect(conn);
-                }
-            }
-        }, 5000);
-    }
-    /**
-     * Disconnect from all projects
-     */
-    disconnect() {
-        this.shuttingDown = true;
-        for (const [_, conn] of this.connections) {
-            // Clear any pending reconnection timers
-            if (conn.reconnectTimer) {
-                clearTimeout(conn.reconnectTimer);
-            }
-            try {
-                this.send(conn, {
-                    v: PROTOCOL_VERSION,
-                    type: 'BYE',
-                    id: generateId(),
-                    ts: Date.now(),
-                    payload: {},
-                });
-                conn.socket.end();
-            }
-            catch {
-                // Ignore
-            }
-        }
-        this.connections.clear();
-        this.leads.clear();
-    }
-}
-//# sourceMappingURL=multi-project-client.js.map

package/dist/bridge/shadow-cli.js

@@ -1,75 +0,0 @@
-import { execFile } from 'node:child_process';
-import { promisify } from 'node:util';
-import { commandExists } from '../utils/command-resolver.js';
-const execFileAsync = promisify(execFile);
-/** Normalize CLI name to a supported identifier */
-function normalizeCli(cli) {
-    if (!cli)
-        return null;
-    const base = cli.trim().split(' ')[0]; // Strip any args
-    const [command] = base.split(':'); // Handle variants like claude:opus
-    const lower = command.toLowerCase();
-    if (lower.startsWith('claude'))
-        return 'claude';
-    if (lower === 'codex' || lower === 'opencode')
-        return 'codex';
-    return null;
-}
-async function isCommandAuthenticated(command) {
-    if (!commandExists(command))
-        return false;
-    try {
-        await execFileAsync(command, ['--version'], { timeout: 4000 });
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-async function detectAuthenticatedCommand(cli) {
-    const candidates = cli === 'claude' ? ['claude'] : ['codex', 'opencode'];
-    for (const candidate of candidates) {
-        if (await isCommandAuthenticated(candidate)) {
-            return candidate;
-        }
-    }
-    return null;
-}
-/**
- * Select the shadow CLI and execution mode based on the primary agent's CLI.
- * - Claude/OpenCode primaries run shadows as subagents (Task tool)
- * - Others fall back to spawning a process using an authenticated CLI
- */
-export async function selectShadowCli(primaryCli, options) {
-    const primary = normalizeCli(primaryCli);
-    const preferred = normalizeCli(options?.preferredShadowCli);
-    // Native subagent support for Claude/OpenCode primaries
-    if (primary) {
-        return {
-            cli: primary,
-            command: primary === 'claude' ? 'claude' : 'codex',
-            mode: 'subagent',
-        };
-    }
-    // Process-mode fallback for non-supporting primaries
-    const fallbackOrder = [];
-    if (preferred)
-        fallbackOrder.push(preferred);
-    fallbackOrder.push('claude', 'codex');
-    const seen = new Set();
-    for (const candidate of fallbackOrder) {
-        if (seen.has(candidate))
-            continue;
-        seen.add(candidate);
-        const authenticatedCommand = await detectAuthenticatedCommand(candidate);
-        if (authenticatedCommand) {
-            return {
-                cli: candidate,
-                command: authenticatedCommand,
-                mode: 'process',
-            };
-        }
-    }
-    throw new Error('No shadow-capable CLI authenticated. Install Claude or OpenCode (codex) and try again.');
-}
-//# sourceMappingURL=shadow-cli.js.map

package/dist/bridge/shadow-config.d.ts

@@ -1,87 +0,0 @@
-/**
- * Shadow Agent Configuration
- * Handles loading and parsing shadow agent configuration from .agent-relay.json.
- *
- * Configuration can be placed in:
- * - Project root: ./.agent-relay.json
- * - Agent-relay dir: ./.agent-relay/config.json
- *
- * Shadow configuration structure:
- * {
- *   "shadows": {
- *     "pairs": {
- *       "Lead": { "shadow": "Auditor", "shadowRole": "reviewer" }
- *     },
- *     "roles": {
- *       "reviewer": { "prompt": "Review code...", "speakOn": ["CODE_WRITTEN"] }
- *     }
- *   }
- * }
- */
-import type { SpeakOnTrigger } from '../protocol/types.js';
-/** Shadow role definition */
-export interface ShadowRoleConfig {
-    /** System prompt for this shadow role */
-    prompt?: string;
-    /** Triggers for when the shadow should speak */
-    speakOn: SpeakOnTrigger[];
-}
-/** Shadow pair definition */
-export interface ShadowPairConfig {
-    /** Name of the shadow agent */
-    shadow: string;
-    /** Role name (references roles config) or preset (reviewer, auditor, active) */
-    shadowRole?: string;
-    /** Override speakOn triggers (takes precedence over role) */
-    speakOn?: SpeakOnTrigger[];
-    /** CLI to use for shadow (defaults to same as primary) */
-    cli?: string;
-}
-/** Shadow configuration section */
-export interface ShadowConfig {
-    /** Primary -> Shadow mappings */
-    pairs: Record<string, ShadowPairConfig>;
-    /** Role definitions */
-    roles?: Record<string, ShadowRoleConfig>;
-}
-/** Full agent-relay configuration file structure */
-export interface AgentRelayConfig {
-    /** Shadow agent configuration */
-    shadows?: ShadowConfig;
-}
-/** Resolved shadow config for a primary agent */
-export interface ResolvedShadowConfig {
-    /** Shadow agent name */
-    shadowName: string;
-    /** Role name (for logging/display) */
-    roleName?: string;
-    /** Resolved speakOn triggers */
-    speakOn: SpeakOnTrigger[];
-    /** System prompt for the shadow */
-    prompt?: string;
-    /** CLI to use for shadow */
-    cli?: string;
-}
-/**
- * Load agent-relay configuration from project root
- * Returns null if no config found
- */
-export declare function loadAgentRelayConfig(projectRoot: string): AgentRelayConfig | null;
-/**
- * Get shadow configuration for a primary agent
- * Returns null if no shadow configured for this agent
- */
-export declare function getShadowForAgent(projectRoot: string, primaryAgentName: string): ResolvedShadowConfig | null;
-/**
- * Get all configured shadow pairs
- */
-export declare function getAllShadowPairs(projectRoot: string): Map<string, ResolvedShadowConfig>;
-/**
- * Check if shadow config exists
- */
-export declare function hasShadowConfig(projectRoot: string): boolean;
-/**
- * Get the config file path that would be used
- */
-export declare function getConfigPath(projectRoot: string): string | null;
-//# sourceMappingURL=shadow-config.d.ts.map