agent-relay 1.1.0 → 1.2.3

package/dist/daemon/router.js

@@ -4,6 +4,7 @@
  */
 import { v4 as uuid } from 'uuid';
 import { PROTOCOL_VERSION, } from '../protocol/types.js';
+import { routerLog } from '../utils/logger.js';
 const DEFAULT_DELIVERY_OPTIONS = {
     ackTimeoutMs: 5000,
     maxAttempts: 5,
@@ -130,7 +131,7 @@ export class Router {
         shadows.push(relationship);
         // Set reverse lookup
         this.primaryByShadow.set(shadowAgent, primaryAgent);
-        console.log(`[router] Shadow bound: ${shadowAgent} -> ${primaryAgent} (speakOn: ${relationship.speakOn.join(', ')})`);
+        routerLog.info(`Shadow bound: ${shadowAgent} -> ${primaryAgent}`, { speakOn: relationship.speakOn });
     }
     /**
      * Unbind a shadow agent from its primary.
@@ -152,7 +153,7 @@ export class Router {
         }
         // Remove reverse lookup
         this.primaryByShadow.delete(shadowAgent);
-        console.log(`[router] Shadow unbound: ${shadowAgent} from ${primaryAgent}`);
+        routerLog.info(`Shadow unbound: ${shadowAgent} from ${primaryAgent}`);
     }
     /**
      * Get all shadows for a primary agent.
@@ -207,7 +208,7 @@ export class Router {
             const sent = target.send(deliver);
             if (sent) {
                 this.trackDelivery(target, deliver);
-                console.log(`[router] Shadow trigger ${trigger} sent to ${shadow.shadowAgent} (primary: ${primaryAgent})`);
+                routerLog.debug(`Shadow trigger ${trigger} sent to ${shadow.shadowAgent}`, { primary: primaryAgent });
                 // Set processing state for triggered shadows - they're expected to respond
                 this.setProcessing(shadow.shadowAgent, deliver.id);
             }
@@ -234,7 +235,7 @@ export class Router {
     route(from, envelope) {
         const senderName = from.agentName;
         if (!senderName) {
-            console.log(`[router] Dropping message - sender has no name`);
+            routerLog.warn('Dropping message - sender has no name');
             return;
         }
         // Agent is responding - clear their processing state
@@ -242,7 +243,7 @@ export class Router {
         this.registry?.recordSend(senderName);
         const to = envelope.to;
         const topic = envelope.topic;
-        console.log(`[router] ${senderName} -> ${to}:${envelope.payload.body?.substring(0, 50)}...`);
+        routerLog.debug(`${senderName} -> ${to}`, { preview: envelope.payload.body?.substring(0, 50) });
         if (to === '*') {
             // Broadcast to all (except sender)
             this.broadcast(senderName, envelope, topic);
@@ -298,7 +299,7 @@ export class Router {
             const sent = target.send(deliver);
             if (sent) {
                 this.trackDelivery(target, deliver);
-                console.log(`[router] Shadow copy to ${shadow.shadowAgent} (${direction} from ${primaryAgent})`);
+                routerLog.debug(`Shadow copy to ${shadow.shadowAgent}`, { direction, primary: primaryAgent });
                 // Note: Don't set processing state for shadow copies - shadow stays passive
             }
         }
@@ -312,15 +313,15 @@ export class Router {
         if (!target) {
             const remoteAgent = this.crossMachineHandler?.isRemoteAgent(to);
             if (remoteAgent) {
-                console.log(`[router] Routing to remote agent: ${to} on ${remoteAgent.daemonName}`);
+                routerLog.info(`Routing to remote agent: ${to}`, { daemonName: remoteAgent.daemonName });
                 return this.sendToRemoteAgent(from, to, envelope, remoteAgent);
             }
-            console.log(`[router] Target "${to}" not found. Available agents: ${Array.from(this.agents.keys()).join(', ')}`);
+            routerLog.warn(`Target "${to}" not found`, { availableAgents: Array.from(this.agents.keys()) });
             return false;
         }
         const deliver = this.createDeliverEnvelope(from, to, envelope, target);
         const sent = target.send(deliver);
-        console.log(`[router] Delivered to ${to}: ${sent ? 'success' : 'failed'}`);
+        routerLog.debug(`Delivered to ${to}`, { success: sent });
         this.persistDeliverEnvelope(deliver);
         if (sent) {
             this.trackDelivery(target, deliver);
@@ -335,7 +336,7 @@ export class Router {
      */
     sendToRemoteAgent(from, to, envelope, remoteAgent) {
         if (!this.crossMachineHandler) {
-            console.log(`[router] Cross-machine handler not available`);
+            routerLog.warn('Cross-machine handler not available');
             return false;
         }
         // Send asynchronously via cloud
@@ -347,7 +348,7 @@ export class Router {
             originalId: envelope.id,
         }).then((sent) => {
             if (sent) {
-                console.log(`[router] Cross-machine message sent to ${to} on ${remoteAgent.daemonName}`);
+                routerLog.info(`Cross-machine message sent to ${to}`, { daemonName: remoteAgent.daemonName });
                 // Persist as cross-machine message
                 this.storage?.saveMessage({
                     id: envelope.id || `cross-${Date.now()}`,
@@ -367,13 +368,13 @@ export class Router {
                     status: 'unread',
                     is_urgent: false,
                     is_broadcast: false,
-                }).catch(err => console.error('[router] Failed to persist cross-machine message:', err));
+                }).catch(err => routerLog.error('Failed to persist cross-machine message', { error: String(err) }));
             }
             else {
-                console.error(`[router] Failed to send cross-machine message to ${to}`);
+                routerLog.error(`Failed to send cross-machine message to ${to}`);
             }
         }).catch(err => {
-            console.error(`[router] Cross-machine send error:`, err);
+            routerLog.error('Cross-machine send error', { error: String(err) });
         });
         // Return true immediately - message is queued
         return true;
@@ -449,7 +450,7 @@ export class Router {
             is_urgent: false,
             is_broadcast: isBroadcast || envelope.to === '*',
         }).catch((err) => {
-            console.error('[router] Failed to persist message', err);
+            routerLog.error('Failed to persist message', { error: String(err) });
         });
     }
     /**
@@ -498,14 +499,14 @@ export class Router {
         this.clearProcessing(agentName);
         const timer = setTimeout(() => {
             this.clearProcessing(agentName);
-            console.log(`[router] Processing timeout for ${agentName}`);
+            routerLog.warn(`Processing timeout for ${agentName}`);
         }, Router.PROCESSING_TIMEOUT_MS);
         this.processingAgents.set(agentName, {
             startedAt: Date.now(),
             messageId,
             timer,
         });
-        console.log(`[router] ${agentName} started processing (message: ${messageId})`);
+        routerLog.debug(`${agentName} started processing`, { messageId });
         this.onProcessingStateChange?.();
     }
     /**
@@ -518,7 +519,7 @@ export class Router {
                 clearTimeout(state.timer);
             }
             this.processingAgents.delete(agentName);
-            console.log(`[router] ${agentName} finished processing`);
+            routerLog.debug(`${agentName} finished processing`);
             this.onProcessingStateChange?.();
         }
     }
@@ -540,10 +541,10 @@ export class Router {
         const statusUpdate = this.storage?.updateMessageStatus?.(ackId, 'acked');
         if (statusUpdate instanceof Promise) {
             statusUpdate.catch(err => {
-                console.error('[router] Failed to record ACK status', err);
+                routerLog.error('Failed to record ACK status', { error: String(err) });
             });
         }
-        console.log(`[router] ACK received for ${ackId}`);
+        routerLog.debug(`ACK received for ${ackId}`);
     }
     /**
      * Clear pending deliveries for a connection (e.g., on disconnect).
@@ -578,32 +579,83 @@ export class Router {
             const now = Date.now();
             const elapsed = now - pending.firstSentAt;
             if (elapsed > this.deliveryOptions.deliveryTtlMs) {
-                console.warn(`[router] Dropping ${deliverId} after TTL (${this.deliveryOptions.deliveryTtlMs}ms)`);
+                routerLog.warn(`Dropping ${deliverId} after TTL`, { ttlMs: this.deliveryOptions.deliveryTtlMs });
                 this.pendingDeliveries.delete(deliverId);
+                // Mark message as failed in storage
+                const statusUpdate = this.storage?.updateMessageStatus?.(deliverId, 'failed');
+                if (statusUpdate instanceof Promise) {
+                    statusUpdate.catch(err => {
+                        routerLog.error(`Failed to update status for ${deliverId}`, { error: String(err) });
+                    });
+                }
                 return;
             }
             if (pending.attempts >= this.deliveryOptions.maxAttempts) {
-                console.warn(`[router] Dropping ${deliverId} after max attempts (${this.deliveryOptions.maxAttempts})`);
+                routerLog.warn(`Dropping ${deliverId} after max attempts`, { maxAttempts: this.deliveryOptions.maxAttempts });
                 this.pendingDeliveries.delete(deliverId);
+                // Mark message as failed in storage
+                const statusUpdate = this.storage?.updateMessageStatus?.(deliverId, 'failed');
+                if (statusUpdate instanceof Promise) {
+                    statusUpdate.catch(err => {
+                        routerLog.error(`Failed to update status for ${deliverId}`, { error: String(err) });
+                    });
+                }
                 return;
             }
             const target = this.connections.get(pending.connectionId);
             if (!target) {
-                console.warn(`[router] Dropping ${deliverId} - connection unavailable`);
+                routerLog.warn(`Dropping ${deliverId} - connection unavailable`);
                 this.pendingDeliveries.delete(deliverId);
+                // Mark message as failed in storage
+                const statusUpdate = this.storage?.updateMessageStatus?.(deliverId, 'failed');
+                if (statusUpdate instanceof Promise) {
+                    statusUpdate.catch(err => {
+                        routerLog.error(`Failed to update status for ${deliverId}`, { error: String(err) });
+                    });
+                }
                 return;
             }
             pending.attempts++;
             const sent = target.send(pending.envelope);
             if (!sent) {
-                console.warn(`[router] Retry failed for ${deliverId} (attempt ${pending.attempts})`);
+                routerLog.warn(`Retry failed for ${deliverId}`, { attempt: pending.attempts });
             }
             else {
-                console.log(`[router] Retried ${deliverId} (attempt ${pending.attempts})`);
+                routerLog.debug(`Retried ${deliverId}`, { attempt: pending.attempts });
             }
             pending.timer = this.scheduleRetry(deliverId);
         }, this.deliveryOptions.ackTimeoutMs);
     }
+    /**
+     * Broadcast a system message to all connected agents.
+     * Used for system notifications like agent death announcements.
+     */
+    broadcastSystemMessage(message, data) {
+        const envelope = {
+            v: PROTOCOL_VERSION,
+            type: 'SEND',
+            id: uuid(),
+            ts: Date.now(),
+            from: '_system',
+            to: '*',
+            payload: {
+                kind: 'message',
+                body: message,
+                data: {
+                    ...data,
+                    _isSystemMessage: true,
+                },
+            },
+        };
+        // Broadcast to all agents
+        for (const [agentName, connection] of this.agents.entries()) {
+            const deliver = this.createDeliverEnvelope('_system', agentName, envelope, connection);
+            const sent = connection.send(deliver);
+            if (sent) {
+                routerLog.debug(`System broadcast sent to ${agentName}`);
+            }
+        }
+    }
     /**
      * Replay any pending (unacked) messages for a resumed session.
      */
@@ -614,7 +666,7 @@ export class Router {
         const pending = await this.storage.getPendingMessagesForSession(connection.agentName, connection.sessionId);
         if (!pending.length)
             return;
-        console.log(`[router] Replaying ${pending.length} messages to ${connection.agentName}`);
+        routerLog.info(`Replaying ${pending.length} messages to ${connection.agentName}`);
         for (const msg of pending) {
             const deliver = {
                 v: PROTOCOL_VERSION,

package/dist/daemon/server.d.ts

@@ -99,6 +99,11 @@ export declare class Daemon {
      * Get list of connected agents.
      */
     getAgents(): string[];
+    /**
+     * Broadcast a system message to all connected agents.
+     * Used for system notifications like agent death announcements.
+     */
+    broadcastSystemMessage(message: string, data?: Record<string, unknown>): void;
     /**
      * Get connection count.
      */

package/dist/daemon/server.js

@@ -14,6 +14,7 @@ import { getProjectPaths } from '../utils/project-namespace.js';
 import { AgentRegistry } from './agent-registry.js';
 import { daemonLog as log } from '../utils/logger.js';
 import { getCloudSync } from './cloud-sync.js';
+import { v4 as uuid } from 'uuid';
 export const DEFAULT_SOCKET_PATH = '/tmp/agent-relay.sock';
 export const DEFAULT_DAEMON_CONFIG = {
     ...DEFAULT_CONFIG,
@@ -232,7 +233,7 @@ export class Daemon {
         const envelope = {
             v: 1,
             type: 'SEND',
-            id: `cross-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+            id: uuid(),
             ts: Date.now(),
             from: `${msg.from.daemonName}:${msg.from.agent}`,
             to: msg.to,
@@ -512,6 +513,13 @@ export class Daemon {
     getAgents() {
         return this.router.getAgents();
     }
+    /**
+     * Broadcast a system message to all connected agents.
+     * Used for system notifications like agent death announcements.
+     */
+    broadcastSystemMessage(message, data) {
+        this.router.broadcastSystemMessage(message, data);
+    }
     /**
      * Get connection count.
      */

package/dist/daemon/services/browser-testing.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Browser Testing Service
+ *
+ * Provides browser automation capabilities for agents running in the workspace.
+ * Uses Playwright for browser control and Xvfb for headless display.
+ *
+ * Features:
+ * - Screenshot capture
+ * - Browser automation via Playwright
+ * - Visual regression testing
+ * - PDF generation
+ */
+export interface ScreenshotOptions {
+    /** Output path for screenshot (default: /tmp/screenshot-{timestamp}.png) */
+    outputPath?: string;
+    /** Full page screenshot */
+    fullPage?: boolean;
+    /** Clip region */
+    clip?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+}
+export interface BrowserTestOptions {
+    /** Browser to use (chromium, firefox, webkit) */
+    browser?: 'chromium' | 'firefox' | 'webkit';
+    /** Headless mode (default: true in container, false with VNC) */
+    headless?: boolean;
+    /** Viewport size */
+    viewport?: {
+        width: number;
+        height: number;
+    };
+    /** Timeout in ms */
+    timeout?: number;
+}
+/**
+ * Check if browser testing is available
+ */
+export declare function isBrowserTestingAvailable(): boolean;
+/**
+ * Take a screenshot of the current display
+ */
+export declare function takeDisplayScreenshot(options?: ScreenshotOptions): Promise<string>;
+/**
+ * Run a Playwright test file
+ */
+export declare function runPlaywrightTest(testFile: string, options?: BrowserTestOptions): Promise<{
+    success: boolean;
+    output: string;
+    screenshots: string[];
+}>;
+/**
+ * Launch a browser and navigate to a URL
+ * Returns the browser PID for later control
+ */
+export declare function launchBrowser(url: string, options?: {
+    browser?: 'chromium' | 'firefox';
+}): Promise<{
+    pid: number;
+}>;
+/**
+ * Generate a Playwright test file from a description
+ */
+export declare function generatePlaywrightTest(name: string, steps: Array<{
+    action: 'goto' | 'click' | 'fill' | 'screenshot' | 'wait';
+    target?: string;
+    value?: string;
+}>): string;
+/**
+ * Run inline Playwright script
+ */
+export declare function runPlaywrightScript(script: string, options?: BrowserTestOptions): Promise<{
+    success: boolean;
+    output: string;
+    result?: unknown;
+}>;
+/**
+ * Get VNC connection info
+ */
+export declare function getVNCInfo(): {
+    available: boolean;
+    vncUrl?: string;
+    noVncUrl?: string;
+};
+//# sourceMappingURL=browser-testing.d.ts.map

package/dist/daemon/services/browser-testing.js

@@ -0,0 +1,244 @@
+/**
+ * Browser Testing Service
+ *
+ * Provides browser automation capabilities for agents running in the workspace.
+ * Uses Playwright for browser control and Xvfb for headless display.
+ *
+ * Features:
+ * - Screenshot capture
+ * - Browser automation via Playwright
+ * - Visual regression testing
+ * - PDF generation
+ */
+import { spawn, execSync } from 'child_process';
+import { existsSync, writeFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+/**
+ * Check if browser testing is available
+ */
+export function isBrowserTestingAvailable() {
+    try {
+        // Check if DISPLAY is set (Xvfb running)
+        if (!process.env.DISPLAY) {
+            return false;
+        }
+        // Check if Playwright is installed
+        execSync('npx playwright --version', { stdio: 'pipe' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Take a screenshot of the current display
+ */
+export async function takeDisplayScreenshot(options = {}) {
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const outputPath = options.outputPath || `/tmp/screenshot-${timestamp}.png`;
+    // Ensure output directory exists
+    const dir = join(outputPath, '..');
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+    return new Promise((resolve, reject) => {
+        const args = [outputPath];
+        if (options.fullPage) {
+            args.unshift('-u'); // Capture including window decorations
+        }
+        const proc = spawn('scrot', args, {
+            env: { ...process.env, DISPLAY: process.env.DISPLAY || ':99' },
+        });
+        proc.on('close', (code) => {
+            if (code === 0) {
+                resolve(outputPath);
+            }
+            else {
+                reject(new Error(`Screenshot failed with code ${code}`));
+            }
+        });
+        proc.on('error', reject);
+    });
+}
+/**
+ * Run a Playwright test file
+ */
+export async function runPlaywrightTest(testFile, options = {}) {
+    const browser = options.browser || 'chromium';
+    const timeout = options.timeout || 30000;
+    return new Promise((resolve) => {
+        const args = ['playwright', 'test', testFile, `--project=${browser}`];
+        if (options.headless !== false) {
+            args.push('--headed=false');
+        }
+        const proc = spawn('npx', args, {
+            env: {
+                ...process.env,
+                DISPLAY: process.env.DISPLAY || ':99',
+                PLAYWRIGHT_BROWSERS_PATH: '/ms-playwright',
+            },
+            timeout,
+        });
+        let output = '';
+        const screenshots = [];
+        proc.stdout.on('data', (data) => {
+            output += data.toString();
+            // Parse screenshot paths from output
+            const matches = data.toString().match(/Screenshot saved: (.+\.png)/g);
+            if (matches) {
+                screenshots.push(...matches.map((m) => m.replace('Screenshot saved: ', '')));
+            }
+        });
+        proc.stderr.on('data', (data) => {
+            output += data.toString();
+        });
+        proc.on('close', (code) => {
+            resolve({
+                success: code === 0,
+                output,
+                screenshots,
+            });
+        });
+        proc.on('error', (err) => {
+            resolve({
+                success: false,
+                output: err.message,
+                screenshots: [],
+            });
+        });
+    });
+}
+/**
+ * Launch a browser and navigate to a URL
+ * Returns the browser PID for later control
+ */
+export async function launchBrowser(url, options = {}) {
+    const browser = options.browser || 'chromium';
+    const command = browser === 'firefox' ? 'firefox' : 'chromium';
+    return new Promise((resolve, reject) => {
+        const args = browser === 'chromium'
+            ? ['--no-sandbox', '--disable-gpu', '--start-maximized', url]
+            : ['--new-window', url];
+        const proc = spawn(command, args, {
+            env: { ...process.env, DISPLAY: process.env.DISPLAY || ':99' },
+            detached: true,
+            stdio: 'ignore',
+        });
+        proc.unref();
+        // Give browser time to start
+        setTimeout(() => {
+            if (proc.pid) {
+                resolve({ pid: proc.pid });
+            }
+            else {
+                reject(new Error('Failed to launch browser'));
+            }
+        }, 1000);
+    });
+}
+/**
+ * Generate a Playwright test file from a description
+ */
+export function generatePlaywrightTest(name, steps) {
+    const testCode = `
+import { test, expect } from '@playwright/test';
+
+test('${name}', async ({ page }) => {
+${steps
+        .map((step) => {
+        switch (step.action) {
+            case 'goto':
+                return `  await page.goto('${step.target}');`;
+            case 'click':
+                return `  await page.click('${step.target}');`;
+            case 'fill':
+                return `  await page.fill('${step.target}', '${step.value}');`;
+            case 'screenshot':
+                return `  await page.screenshot({ path: '${step.target || 'screenshot.png'}' });`;
+            case 'wait':
+                return `  await page.waitForTimeout(${step.value || 1000});`;
+            default:
+                return `  // Unknown action: ${step.action}`;
+        }
+    })
+        .join('\n')}
+});
+`.trim();
+    return testCode;
+}
+/**
+ * Run inline Playwright script
+ */
+export async function runPlaywrightScript(script, options = {}) {
+    const tempDir = '/tmp/playwright-scripts';
+    if (!existsSync(tempDir)) {
+        mkdirSync(tempDir, { recursive: true });
+    }
+    const scriptPath = join(tempDir, `script-${Date.now()}.mjs`);
+    // Wrap script with Playwright imports and browser launch
+    const wrappedScript = `
+import { chromium, firefox, webkit } from 'playwright';
+
+async function run() {
+  const browser = await ${options.browser || 'chromium'}.launch({
+    headless: ${options.headless !== false},
+  });
+  const context = await browser.newContext({
+    viewport: ${JSON.stringify(options.viewport || { width: 1920, height: 1080 })},
+  });
+  const page = await context.newPage();
+
+  try {
+    ${script}
+  } finally {
+    await browser.close();
+  }
+}
+
+run().catch(console.error);
+`;
+    writeFileSync(scriptPath, wrappedScript);
+    return new Promise((resolve) => {
+        const proc = spawn('node', [scriptPath], {
+            env: {
+                ...process.env,
+                DISPLAY: process.env.DISPLAY || ':99',
+            },
+            timeout: options.timeout || 30000,
+        });
+        let output = '';
+        proc.stdout.on('data', (data) => {
+            output += data.toString();
+        });
+        proc.stderr.on('data', (data) => {
+            output += data.toString();
+        });
+        proc.on('close', (code) => {
+            resolve({
+                success: code === 0,
+                output,
+            });
+        });
+        proc.on('error', (err) => {
+            resolve({
+                success: false,
+                output: err.message,
+            });
+        });
+    });
+}
+/**
+ * Get VNC connection info
+ */
+export function getVNCInfo() {
+    const vncEnabled = process.env.VNC_ENABLED !== 'false';
+    const vncPort = process.env.VNC_PORT || '5900';
+    const noVncPort = process.env.NOVNC_PORT || '6080';
+    const hostname = process.env.HOSTNAME || 'localhost';
+    return {
+        available: vncEnabled,
+        vncUrl: vncEnabled ? `vnc://${hostname}:${vncPort}` : undefined,
+        noVncUrl: vncEnabled ? `http://${hostname}:${noVncPort}/vnc.html` : undefined,
+    };
+}
+//# sourceMappingURL=browser-testing.js.map