agents-dojo 0.1.3 → 0.1.5

package/README.md

@@ -24,10 +24,14 @@ See `agents/_template_echo/` for a complete manifest reference.
 
 ## Monitor GUI
 
+The Monitor GUI starts automatically when you run `agents-dojo`. It picks a free
+port for the WebSocket and launches the Vite dev server (installing dependencies
+on first run). The GUI URL is printed to the console.
+
 ```bash
-agents-dojo --monitor-port=41242
-cd monitor && npm install && npm run dev
-# Open http://localhost:5173
+agents-dojo                       # monitor starts automatically
+agents-dojo --monitor-port=9000   # use a specific WS port
+agents-dojo --no-monitor          # disable the monitor
 ```
 
 ## Architecture

package/dist/agent-executor.js

@@ -204,8 +204,7 @@ function extractPreview(parts) {
         return '';
     for (const p of parts) {
         if (p && typeof p === 'object' && p.kind === 'text' && typeof p.text === 'string') {
-            const t = p.text;
-            return t.length > 80 ? t.slice(0, 80) + '…' : t;
+            return p.text;
         }
     }
     return '';

package/dist/cli.js

@@ -1,7 +1,11 @@
 #!/usr/bin/env node
-import { resolve, join } from 'path';
+import { resolve, join, dirname } from 'path';
 import { existsSync, mkdirSync, writeFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { spawn, execSync } from 'child_process';
 import { createServer } from './server.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
 // ── init command ──────────────────────────────────────────
 const ECHO_MANIFEST = `{
   "id": "echo",
@@ -140,7 +144,7 @@ function installCallAgentSkill(agentDir) {
 export const DEFAULT_ARGS = {
     agentsDir: './agents',
     port: 41241,
-    monitorPort: 41242,
+    monitorPort: 0, // 0 = OS picks a free port
     singleAgent: null,
     help: false,
 };
@@ -172,17 +176,149 @@ function printHelp() {
 
 Commands:
   init                   Create agents/echo/ example in the current directory
+  chat <agentId> <msg>   One-shot chat with an agent (connects to a running server)
   (default)              Start the A2A server
 
 Options:
   --agents-dir <path>    Directory containing agent subdirectories (default: ${DEFAULT_ARGS.agentsDir})
   --port <port>          A2A HTTP port (default: ${DEFAULT_ARGS.port})
-  --monitor-port <port>  Monitor WebSocket port (default: ${DEFAULT_ARGS.monitorPort})
-  --no-monitor           Disable Monitor WebSocket
+  --monitor-port <port>  Monitor WebSocket port (default: auto)
+  --no-monitor           Disable Monitor GUI
   --agent=<id>           Single Agent mode: only load and serve the named agent
   -h, --help             Show this help
 `);
 }
+// ── chat command ─────────────────────────────────────────
+async function runChat(agentId, message, port) {
+    const { v4: uuidv4 } = await import('uuid');
+    const body = {
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'message/send',
+        params: {
+            message: {
+                messageId: uuidv4(),
+                kind: 'message',
+                role: 'user',
+                parts: [{ kind: 'text', text: message }],
+            },
+        },
+    };
+    const res = await fetch(`http://localhost:${port}/a2a/${agentId}`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(body),
+    });
+    if (!res.ok) {
+        console.error(`Error: A2A server returned ${res.status}`);
+        const text = await res.text();
+        if (text)
+            console.error(text);
+        process.exit(1);
+    }
+    const json = await res.json();
+    const result = json.result;
+    if (!result) {
+        console.error('Error: no result in response');
+        process.exit(1);
+    }
+    // Extract reply text
+    let replyText = '';
+    for (const a of (result.artifacts ?? [])) {
+        for (const p of (a.parts ?? [])) {
+            if (p.kind === 'text')
+                replyText += p.text;
+        }
+    }
+    if (!replyText) {
+        const statusMsg = result.status?.message;
+        if (statusMsg) {
+            for (const p of (statusMsg.parts ?? [])) {
+                if (p.kind === 'text')
+                    replyText += p.text;
+            }
+        }
+    }
+    if (replyText) {
+        console.log(replyText);
+    }
+    else {
+        console.log('(no response)');
+    }
+}
+// ── monitor GUI launcher ─────────────────────────────────
+/** Resolve the monitor/ directory shipped alongside the package. */
+function resolveMonitorDir() {
+    // __dirname is dist/ after build, so monitor/ is one level up
+    return resolve(__dirname, '..', 'monitor');
+}
+function startMonitorGui(monitorWsPort) {
+    const monitorDir = resolveMonitorDir();
+    if (!existsSync(join(monitorDir, 'package.json'))) {
+        console.warn('[agents-dojo] Monitor GUI not found — skipping.');
+        return null;
+    }
+    // Auto-install monitor deps if missing
+    if (!existsSync(join(monitorDir, 'node_modules'))) {
+        console.log('[agents-dojo] Installing monitor dependencies…');
+        try {
+            execSync('npm install --no-audit --no-fund', { cwd: monitorDir, stdio: 'inherit' });
+        }
+        catch {
+            console.warn('[agents-dojo] Failed to install monitor dependencies — skipping GUI.');
+            return null;
+        }
+    }
+    const wsUrl = `ws://localhost:${monitorWsPort}/monitor`;
+    const child = spawn(join(monitorDir, 'node_modules', '.bin', 'vite'), [], {
+        cwd: monitorDir,
+        stdio: ['ignore', 'pipe', 'pipe'],
+        env: {
+            ...process.env,
+            VITE_MONITOR_WS_URL: wsUrl,
+        },
+    });
+    child.stdout?.on('data', (data) => {
+        const line = data.toString().trim();
+        if (line) {
+            // Extract and print the local URL from vite output
+            const urlMatch = line.match(/Local:\s+(https?:\/\/\S+)/);
+            if (urlMatch) {
+                console.log(`[agents-dojo] Monitor GUI: ${urlMatch[1]}`);
+            }
+            else if (line.includes('ready in') || line.includes('VITE')) {
+                // Print vite ready messages
+                console.log(`[agents-dojo] ${line}`);
+            }
+        }
+    });
+    child.stderr?.on('data', (data) => {
+        const line = data.toString().trim();
+        if (line)
+            console.error(`[monitor] ${line}`);
+    });
+    child.on('error', (err) => {
+        console.warn(`[agents-dojo] Failed to start Monitor GUI: ${err.message}`);
+    });
+    return child;
+}
+/** Ensure child processes are killed on exit. */
+function registerCleanup(child) {
+    const kill = () => {
+        if (!child.killed) {
+            child.kill('SIGTERM');
+            // Force kill after 2s if SIGTERM didn't work
+            setTimeout(() => {
+                if (!child.killed)
+                    child.kill('SIGKILL');
+            }, 2000).unref();
+        }
+    };
+    process.on('exit', kill);
+    process.on('SIGINT', () => { kill(); process.exit(0); });
+    process.on('SIGTERM', () => { kill(); process.exit(0); });
+}
+// ── main ─────────────────────────────────────────────────
 async function main() {
     const rawArgs = process.argv.slice(2);
     // Handle `agents-dojo init [dir]`
@@ -190,6 +326,24 @@ async function main() {
         runInit(resolve(rawArgs[1] ?? '.'));
         return;
     }
+    // Handle `agents-dojo chat <agentId> <message...>`
+    if (rawArgs[0] === 'chat') {
+        const agentId = rawArgs[1];
+        const message = rawArgs.slice(2).join(' ');
+        if (!agentId || !message) {
+            console.error('Usage: agents-dojo chat <agentId> <message>');
+            process.exit(1);
+        }
+        // Check for --port flag in remaining args
+        let port = DEFAULT_ARGS.port;
+        for (let i = 2; i < rawArgs.length; i++) {
+            if (rawArgs[i] === '--port' && rawArgs[i + 1]) {
+                port = parseInt(rawArgs[++i], 10);
+            }
+        }
+        await runChat(agentId, message, port);
+        return;
+    }
     const args = parseArgs(rawArgs);
     if (args.help) {
         printHelp();
@@ -197,9 +351,6 @@ async function main() {
     }
     console.log(`[agents-dojo] agents-dir: ${args.agentsDir}`);
     console.log(`[agents-dojo] A2A port: ${args.port}`);
-    if (args.monitorPort !== null) {
-        console.log(`[agents-dojo] Monitor port: ${args.monitorPort}`);
-    }
     if (args.singleAgent) {
         console.log(`[agents-dojo] Single agent mode: ${args.singleAgent}`);
     }
@@ -210,6 +361,17 @@ async function main() {
         singleAgent: args.singleAgent ?? undefined,
     });
     console.log(`[agents-dojo] ${server.registry.list().length} agents loaded: ${server.registry.list().join(', ')}`);
+    // Auto-start monitor GUI
+    if (server.monitorPort) {
+        console.log(`[agents-dojo] Monitor WS port: ${server.monitorPort}`);
+        const monitorChild = startMonitorGui(server.monitorPort);
+        if (monitorChild) {
+            registerCleanup(monitorChild);
+        }
+    }
+    else {
+        console.log(`[agents-dojo] Monitor disabled.`);
+    }
     console.log(`[agents-dojo] Ready.`);
 }
 main().catch((err) => {

package/dist/event-translator.js

@@ -30,7 +30,7 @@ export function createTranslator(ctx) {
             type: 'task_status',
             taskId: ctx.taskId,
             state: 'working',
-            message: text.length > 80 ? text.slice(0, 77) + '...' : text,
+            message: text,
         });
     }
     function publishCompleted() {

package/dist/monitor-bus.d.ts

@@ -30,6 +30,12 @@ export type MonitorEvent = {
     taskId: string;
     toolName: string;
     success: boolean;
+} | {
+    type: 'chat_response';
+    chatId: string;
+    agentId: string;
+    text: string;
+    final: boolean;
 };
 export type MonitorSubscriber = (event: MonitorEvent) => void;
 export type Unsubscribe = () => void;

package/dist/monitor-ws.d.ts

@@ -7,6 +7,8 @@ export interface MonitorWsOptions {
     bus: MonitorBus;
     path: string;
     registry: AgentRegistry;
+    /** A2A server port — needed to proxy chat commands. */
+    a2aPort: number;
 }
 export type MonitorCommand = {
     type: 'reload';
@@ -16,6 +18,11 @@ export type MonitorCommand = {
     agentId: string;
     x: number;
     y: number;
+} | {
+    type: 'chat';
+    chatId: string;
+    agentId: string;
+    message: string;
 };
 export type MonitorCommandHandler = (cmd: MonitorCommand) => void | Promise<void>;
 export interface MonitorWsHandle {

package/dist/monitor-ws.js

@@ -1,9 +1,10 @@
 // src/monitor-ws.ts
 import { WebSocketServer, WebSocket } from 'ws';
+import { v4 as uuidv4 } from 'uuid';
 export function createMonitorWs(opts) {
     const clients = new Set();
     const wss = new WebSocketServer({ server: opts.server, path: opts.path });
-    function handleCommand(cmd) {
+    function handleCommand(cmd, senderWs) {
         if (cmd.type === 'reload') {
             const result = opts.registry.reload(cmd.agentId);
             // WS protocol is fire-and-forget for commands; on failure, log so the
@@ -18,6 +19,83 @@ export function createMonitorWs(opts) {
             if (!agent)
                 return;
             agent.manifest.monitor = { ...agent.manifest.monitor, position: { x: cmd.x, y: cmd.y } };
+            return;
+        }
+        if (cmd.type === 'chat') {
+            handleChat(cmd, senderWs).catch((err) => {
+                console.error(`[monitor-ws] chat error for "${cmd.agentId}":`, err);
+                const errEvent = {
+                    type: 'chat_response',
+                    chatId: cmd.chatId,
+                    agentId: cmd.agentId,
+                    text: `Error: ${err instanceof Error ? err.message : String(err)}`,
+                    final: true,
+                };
+                if (senderWs.readyState === WebSocket.OPEN) {
+                    senderWs.send(JSON.stringify(errEvent));
+                }
+            });
+        }
+    }
+    /** Proxy a chat message to the A2A endpoint and stream the reply back. */
+    async function handleChat(cmd, senderWs) {
+        const body = {
+            jsonrpc: '2.0',
+            id: 1,
+            method: 'message/send',
+            params: {
+                message: {
+                    messageId: uuidv4(),
+                    kind: 'message',
+                    role: 'user',
+                    parts: [{ kind: 'text', text: cmd.message }],
+                },
+            },
+        };
+        const res = await fetch(`http://localhost:${opts.a2aPort}/a2a/${cmd.agentId}`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(body),
+        });
+        if (!res.ok) {
+            throw new Error(`A2A returned ${res.status}: ${await res.text()}`);
+        }
+        const json = await res.json();
+        // Extract the agent's reply text from the A2A JSON-RPC response
+        let replyText = '';
+        const result = json.result;
+        if (result) {
+            // Try artifacts first (main response content)
+            const artifacts = result.artifacts ?? [];
+            for (const a of artifacts) {
+                for (const p of (a.parts ?? [])) {
+                    if (p.kind === 'text')
+                        replyText += p.text;
+                }
+            }
+            // Fall back to status message
+            if (!replyText) {
+                const statusMsg = result.status?.message;
+                if (statusMsg) {
+                    for (const p of (statusMsg.parts ?? [])) {
+                        if (p.kind === 'text')
+                            replyText += p.text;
+                    }
+                }
+            }
+        }
+        if (!replyText)
+            replyText = '(no response)';
+        // Send the response only to the requesting client
+        const event = {
+            type: 'chat_response',
+            chatId: cmd.chatId,
+            agentId: cmd.agentId,
+            text: replyText,
+            final: true,
+        };
+        if (senderWs.readyState === WebSocket.OPEN) {
+            senderWs.send(JSON.stringify(event));
         }
     }
     wss.on('connection', (ws) => {
@@ -40,8 +118,8 @@ export function createMonitorWs(opts) {
                 const parsed = JSON.parse(data.toString());
                 if (parsed &&
                     typeof parsed === 'object' &&
-                    (parsed.type === 'reload' || parsed.type === 'set_position')) {
-                    handleCommand(parsed);
+                    (parsed.type === 'reload' || parsed.type === 'set_position' || parsed.type === 'chat')) {
+                    handleCommand(parsed, ws);
                 }
             }
             catch {

package/dist/server.d.ts

@@ -11,6 +11,8 @@ export interface DojoServer {
     registry: AgentRegistry;
     bus: ReturnType<typeof createMonitorBus>;
     httpServer: ReturnType<typeof createHttpServer>;
+    /** Actual monitor WebSocket port (undefined when --no-monitor). */
+    monitorPort?: number;
     close: () => Promise<void>;
 }
 export declare function createServer(opts: CreateServerOptions): Promise<DojoServer>;

package/dist/server.js

@@ -39,18 +39,28 @@ export async function createServer(opts) {
         res.json({ dates: listLogDates(logDir) });
     });
     const httpServer = createHttpServer(app);
-    if (opts.monitorPort) {
-        const monitorHttp = createHttpServer();
-        createMonitorWs({ server: monitorHttp, bus, path: '/monitor', registry });
+    // Listen on main server first so we know the actual port (important when port=0)
+    await new Promise((r) => httpServer.listen(opts.port ?? 41241, r));
+    const actualA2APort = httpServer.address().port;
+    let monitorHttp;
+    let actualMonitorPort;
+    if (opts.monitorPort !== undefined) {
+        // Bind monitor on a separate server (port 0 = OS picks a free port)
+        monitorHttp = createHttpServer();
+        createMonitorWs({ server: monitorHttp, bus, path: '/monitor', registry, a2aPort: actualA2APort });
         await new Promise((r) => monitorHttp.listen(opts.monitorPort, r));
+        actualMonitorPort = monitorHttp.address().port;
     }
-    await new Promise((r) => httpServer.listen(opts.port ?? 41241, r));
     return {
         registry,
         bus,
         httpServer,
+        monitorPort: actualMonitorPort,
         close: () => new Promise((resolve) => {
-            httpServer.close(() => resolve());
+            const closeMonitor = monitorHttp
+                ? new Promise((r) => monitorHttp.close(() => r()))
+                : Promise.resolve();
+            httpServer.close(() => closeMonitor.then(resolve));
         }),
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agents-dojo",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "A2A-compatible Agent framework built on Claude Code SDK",
   "type": "module",
   "main": "dist/index.js",