agents-dojo 0.1.10 → 0.1.11

package/dist/claude-bridge.js

@@ -1,6 +1,6 @@
 // src/claude-bridge.ts
 import { join } from 'path';
-import { existsSync, mkdirSync, symlinkSync } from 'fs';
+import { existsSync, mkdirSync, symlinkSync, lstatSync, unlinkSync } from 'fs';
 import { query } from '@anthropic-ai/claude-agent-sdk';
 export async function* runClaude(params) {
     const { agent, contentBlocks, onEvent, abortController } = params;
@@ -22,16 +22,31 @@ export async function* runClaude(params) {
         ? (m.configDir.startsWith('/') ? m.configDir : join(agent.agentDir, m.configDir))
         : join(agent.agentDir, '.claude');
     env.CLAUDE_CONFIG_DIR = agentConfigDir;
-    // Ensure the agent's .claude dir exists and symlink global settings (auth, permissions).
-    // Symlink keeps all agents in sync with the user's global config automatically.
+    // Ensure the agent's .claude dir exists and symlink global config files.
+    // Symlinks keep all agents in sync with the user's global config automatically.
     mkdirSync(agentConfigDir, { recursive: true });
-    const globalSettings = join(process.env.HOME ?? '', '.claude', 'settings.json');
-    const localSettings = join(agentConfigDir, 'settings.json');
-    if (existsSync(globalSettings) && !existsSync(localSettings)) {
+    const globalDir = join(process.env.HOME ?? '', '.claude');
+    // Symlink settings.json, .credentials.json (auth), and .claude.json (user identity)
+    for (const file of ['settings.json', '.credentials.json', '.claude.json']) {
+        const globalFile = join(globalDir, file);
+        const localFile = join(agentConfigDir, file);
+        if (!existsSync(globalFile))
+            continue;
+        // Replace regular files with symlinks (but keep existing symlinks)
         try {
-            symlinkSync(globalSettings, localSettings);
+            const stat = lstatSync(localFile);
+            if (!stat.isSymbolicLink()) {
+                unlinkSync(localFile);
+                symlinkSync(globalFile, localFile);
+            }
+        }
+        catch {
+            // File doesn't exist — create symlink
+            try {
+                symlinkSync(globalFile, localFile);
+            }
+            catch { /* ignore */ }
         }
-        catch { /* race or permission — ignore */ }
     }
     const options = {
         cwd: agent.agentDir,

package/dist/cli.js

@@ -238,7 +238,7 @@ function installCallAgentSkill(agentDir) {
 export const DEFAULT_ARGS = {
     agentsDir: './agents',
     port: 41241,
-    monitorPort: 0, // 0 = OS picks a free port
+    monitorPort: 0, // 0 = OS picks a free port; frontend discovers via /monitor/info
     singleAgent: null,
     help: false,
 };
@@ -305,7 +305,7 @@ function resolveMonitorDir() {
     // __dirname is dist/ after build, so monitor/ is one level up
     return resolve(__dirname, '..', 'monitor');
 }
-function startMonitorGui(monitorWsPort) {
+function startMonitorGui(monitorWsPort, a2aPort = 41241) {
     const monitorDir = resolveMonitorDir();
     if (!existsSync(join(monitorDir, 'package.json'))) {
         console.warn('[agents-dojo] Monitor GUI not found — skipping.');
@@ -329,6 +329,7 @@ function startMonitorGui(monitorWsPort) {
         env: {
             ...process.env,
             VITE_MONITOR_WS_URL: wsUrl,
+            VITE_A2A_PORT: String(a2aPort),
         },
     });
     child.stdout?.on('data', (data) => {
@@ -417,7 +418,7 @@ async function main() {
     // Auto-start monitor GUI
     if (server.monitorPort) {
         console.log(`[agents-dojo] Monitor WS port: ${server.monitorPort}`);
-        const monitorChild = startMonitorGui(server.monitorPort);
+        const monitorChild = startMonitorGui(server.monitorPort, args.port);
         if (monitorChild) {
             registerCleanup(monitorChild);
         }

package/dist/server.js

@@ -71,6 +71,11 @@ export async function createServer(opts) {
         createMonitorWs({ server: monitorHttp, bus, path: '/monitor', registry, executors: a2a.executors });
         await new Promise((r) => monitorHttp.listen(opts.monitorPort, r));
         actualMonitorPort = monitorHttp.address().port;
+        // Discovery endpoint: frontend fetches this to find the WS port
+        app.get('/monitor/info', (_req, res) => {
+            res.header('Access-Control-Allow-Origin', '*');
+            res.json({ wsPort: actualMonitorPort, wsUrl: `ws://localhost:${actualMonitorPort}/monitor` });
+        });
     }
     return {
         registry,

package/monitor/src/components/LogPage.tsx

@@ -1,6 +1,6 @@
 import React, { useEffect, useState, useRef } from 'react';
 
-const API_BASE = 'http://localhost:41241';
+const API_BASE = '';  // relative path, proxied by Vite
 
 interface ChatMessage {
   timestamp: string;

package/monitor/src/lib/dojo-app.ts

@@ -126,6 +126,14 @@ export class DojoApp {
   private agents = new Map<string, AgentState>();
   private interactables: InteractableState[] = [];
   private ready = false;
+  // Master state
+  private masterContainer!: Container;
+  private masterSprite!: Sprite;
+  private masterX = MASTER_POS.x;
+  private masterY = MASTER_POS.y;
+  private masterTargetX = MASTER_POS.x;
+  private masterTargetY = MASTER_POS.y;
+  private masterFacingLeft = false;
   // Master bubble state
   private masterBubble!: Container;
   private masterBubbleBg!: Graphics;
@@ -247,13 +255,13 @@ export class DojoApp {
   }
 
   private createMaster() {
-    const masterContainer = new Container();
-    masterContainer.x = MASTER_POS.x;
-    masterContainer.y = MASTER_POS.y;
+    this.masterContainer = new Container();
+    this.masterContainer.x = MASTER_POS.x;
+    this.masterContainer.y = MASTER_POS.y;
 
-    const spr = new Sprite(this.masterFrames[0]);
-    spr.anchor.set(0.5, 1);
-    spr.scale.set(SPRITE_SCALE);
+    this.masterSprite = new Sprite(this.masterFrames[0]);
+    this.masterSprite.anchor.set(0.5, 1);
+    this.masterSprite.scale.set(SPRITE_SCALE);
 
     const nameBg = new Graphics();
     nameBg.roundRect(-28, -FRAME_SIZE * SPRITE_SCALE - 14, 56, 14, 3);
@@ -271,8 +279,8 @@ export class DojoApp {
     this.masterBubbleText.anchor.set(0.5, 0);
     this.masterBubble.addChild(this.masterBubbleBg, this.masterBubbleText);
 
-    masterContainer.addChild(spr, nameBg, label, this.masterBubble);
-    this.scene.addChild(masterContainer);
+    this.masterContainer.addChild(this.masterSprite, nameBg, label, this.masterBubble);
+    this.scene.addChild(this.masterContainer);
   }
 
   private createAgent(id: string, agent: Agent) {
@@ -428,27 +436,29 @@ export class DojoApp {
     }
     // Priority 3: Client task states
     else if (state === 'submitted') {
-      // Walk to Master
-      s.animKey = 'walk';
-      s.targetX = MASTER_POS.x + 30; s.targetY = MASTER_POS.y;
+      // Agent stays on cushion (sit), Master walks to agent
+      s.animKey = 'sit';
+      s.targetX = agent.homePosition.x; s.targetY = agent.homePosition.y;
+      // Tell Master to walk to this agent
+      this.masterTargetX = agent.homePosition.x + 30;
+      this.masterTargetY = agent.homePosition.y;
       s.visitedMaster = false;
     }
     else if (state === 'working' || state === 'tool_call') {
-      if (!s.visitedMaster) {
-        // First visit master, then go to stake
-        s.animKey = 'walk';
-        s.targetX = MASTER_POS.x + 30; s.targetY = MASTER_POS.y;
-      } else {
-        // At stake, attack
-        s.animKey = s.arrived ? 'attack' : 'walk';
-        s.targetX = agent.stakePosition.x + STAKE_ATTACK_OFFSET_X;
-        s.targetY = agent.stakePosition.y;
-      }
+      // Agent walks to stake and attacks
+      s.animKey = s.arrived ? 'attack' : 'walk';
+      s.targetX = agent.stakePosition.x + STAKE_ATTACK_OFFSET_X;
+      s.targetY = agent.stakePosition.y;
+      // Master returns home
+      this.masterTargetX = MASTER_POS.x;
+      this.masterTargetY = MASTER_POS.y;
     }
     else if (state === 'input-required' || state === 'auth-required') {
-      // Walk back to Master and wait
+      // Agent waits at stake, Master comes back to agent
       s.animKey = s.arrived ? 'idle' : 'walk';
-      s.targetX = MASTER_POS.x + 30; s.targetY = MASTER_POS.y;
+      s.targetX = agent.homePosition.x; s.targetY = agent.homePosition.y;
+      this.masterTargetX = agent.homePosition.x + 30;
+      this.masterTargetY = agent.homePosition.y;
     }
     else if (state === 'completed' || state === 'canceled') {
       // Walk home
@@ -477,19 +487,20 @@ export class DojoApp {
       }
     }
     else if (state === 'rejected') {
-      // Head shake at Master, then walk home
-      if (!s.arrived && Math.hypot(s.x - MASTER_POS.x - 30, s.y - MASTER_POS.y) > MOVE_SPEED * 3) {
-        s.animKey = 'walk';
-        s.targetX = MASTER_POS.x + 30; s.targetY = MASTER_POS.y;
-      } else if (s.rejectTimer === undefined) {
+      // Agent stays at cushion, shakes head when Master arrives
+      s.targetX = agent.homePosition.x; s.targetY = agent.homePosition.y;
+      this.masterTargetX = agent.homePosition.x + 30;
+      this.masterTargetY = agent.homePosition.y;
+      if (s.rejectTimer === undefined) {
         s.animKey = 'head_shake';
         s.rejectTimer = 0;
       } else if (s.rejectTimer < 1500) {
         s.animKey = 'head_shake';
       } else {
-        s.animKey = 'walk';
-        s.targetX = agent.homePosition.x; s.targetY = agent.homePosition.y;
-        s.arrived = false;
+        // Done shaking, go back to sit
+        s.animKey = 'sit';
+        this.masterTargetX = MASTER_POS.x;
+        this.masterTargetY = MASTER_POS.y;
       }
     }
     // else: idle — handled by auto-behavior in tick
@@ -546,36 +557,10 @@ export class DojoApp {
       }
       if (s.idleGrace > 0) s.idleGrace -= dt;
 
-      // Auto-behavior when idle (sit on cushion, occasionally wander)
-      // Skip during grace period after task completion
-      if (isIdle && !isInPeerChat && s.idleGrace <= 0) {
-        const action = s.autoAction;
-        if (action.kind === 'sit') {
-          // Sit on cushion (home position)
-          s.animKey = 'sit';
-          s.targetX = agent.homePosition.x; s.targetY = agent.homePosition.y;
-          action.timer += dt;
-          if (action.timer >= (action.duration ?? 5000)) {
-            s.autoAction = this.pickAutoAction();
-            s.arrived = false;
-          }
-        } else if (action.kind === 'wander') {
-          s.animKey = 'walk';
-          s.targetX = action.target!.x;
-          s.targetY = action.target!.y;
-          if (s.arrived) {
-            s.autoAction = this.pickAutoAction();
-            s.arrived = false;
-          }
-        } else if (action.kind === 'daydream' || action.kind === 'pause') {
-          s.animKey = action.kind === 'daydream' ? 'daydream' : 'idle';
-          s.targetX = s.x; s.targetY = s.y;
-          action.timer += dt;
-          if (action.timer >= (action.duration ?? 3000)) {
-            s.autoAction = this.pickAutoAction();
-            s.arrived = false;
-          }
-        }
+      // Auto-behavior when idle: always sit on cushion
+      if (isIdle && !isInPeerChat) {
+        s.animKey = s.arrived ? 'sit' : 'walk';
+        s.targetX = agent.homePosition.x; s.targetY = agent.homePosition.y;
       }
 
       // Advance fail/reject timers
@@ -595,28 +580,17 @@ export class DojoApp {
         if (Math.abs(dx) > 0.5) s.facingLeft = dx < 0;
         let nx = s.x + (dx / dist) * MOVE_SPEED;
         let ny = s.y + (dy / dist) * MOVE_SPEED;
-        // Obstacle avoidance when idle wandering
-        if (isIdle && !isInPeerChat) {
-          for (const o of OBSTACLES) {
-            const od = Math.hypot(nx - o.x, ny - o.y);
-            if (od < o.r + 8 && od > 0.1) {
-              nx = o.x + ((nx - o.x) / od) * (o.r + 8);
-              ny = o.y + ((ny - o.y) / od) * (o.r + 8);
-            }
-          }
-        }
+        // Obstacle avoidance: only when not heading to a specific target
+        // (idle agents heading home, or task agents heading to stake/master, skip avoidance)
+        // Avoidance is only useful during peer-chat or other free movement
         s.x = nx; s.y = ny;
       } else {
         if (!s.arrived) { s.x = s.targetX; s.y = s.targetY; }
         s.arrived = true;
       }
 
-      // Master visit: when agent arrives at Master during working state
-      if ((state === 'working' || state === 'tool_call') && !s.visitedMaster && s.arrived
-          && Math.hypot(s.x - MASTER_POS.x - 30, s.y - MASTER_POS.y) < MOVE_SPEED * 3) {
-        s.visitedMaster = true;
-        s.arrived = false;
-      }
+      // Note: visitedMaster is now set by the Master movement block when Master
+      // arrives at the agent's cushion position.
 
       // Peer chat: face toward partner when arrived
       if (isInPeerChat && s.arrived) {
@@ -687,6 +661,44 @@ export class DojoApp {
       }
     }
 
+    // ── Master movement ──────────────────────────────────────
+    {
+      const dx = this.masterTargetX - this.masterX;
+      const dy = this.masterTargetY - this.masterY;
+      const dist = Math.hypot(dx, dy);
+      if (dist > MOVE_SPEED * 2) {
+        if (Math.abs(dx) > 0.5) this.masterFacingLeft = dx < 0;
+        this.masterX += (dx / dist) * MOVE_SPEED;
+        this.masterY += (dy / dist) * MOVE_SPEED;
+        // Use walk frame for master (alternate between frame 0 and 1)
+        const walkFrame = Math.floor(performance.now() / 200) % 2;
+        this.masterSprite.texture = this.masterFrames[walkFrame] ?? this.masterFrames[0];
+      } else {
+        this.masterX = this.masterTargetX;
+        this.masterY = this.masterTargetY;
+        this.masterSprite.texture = this.masterFrames[0];
+
+        // When Master arrives at an agent in submitted state → transition agent to working
+        // (The store will handle this via the normal task_status flow from backend,
+        //  but visually we detect Master arrival to trigger agent getting up)
+        for (const [, s] of this.agents) {
+          if (!s.visitedMaster && s.animKey === 'sit') {
+            const agentStore = [...useMonitorStore.getState().agents.values()].find(
+              a => a.state === 'submitted' &&
+                Math.abs(a.homePosition.x + 30 - this.masterX) < 5 &&
+                Math.abs(a.homePosition.y - this.masterY) < 5
+            );
+            if (agentStore) {
+              s.visitedMaster = true;
+            }
+          }
+        }
+      }
+      this.masterSprite.scale.x = (this.masterFacingLeft ? -1 : 1) * SPRITE_SCALE;
+      this.masterContainer.x = this.masterX;
+      this.masterContainer.y = this.masterY;
+    }
+
     // Master bubble: show client's message with chunked display
     const masterMsg = useMonitorStore.getState().masterMessage;
     if (masterMsg) {
@@ -768,12 +780,8 @@ export class DojoApp {
   }
 
   private pickAutoAction() {
-    const r = Math.random();
-    // Prefer sitting on cushion (idle default per R10: "坐在蒲团上发呆")
-    if (r < 0.45) return { kind: 'sit', duration: 5000 + Math.random() * 8000, timer: 0 };
-    if (r < 0.70) return { kind: 'wander', target: randomFloorPos(), timer: 0 };
-    if (r < 0.85) return { kind: 'daydream', duration: 3000 + Math.random() * 5000, timer: 0 };
-    return { kind: 'pause', duration: 1000 + Math.random() * 2000, timer: 0 };
+    // Idle agents always sit on cushion
+    return { kind: 'sit', timer: 0 };
   }
 
   private animToStoreAnim(key: string): AgentAnim {

package/monitor/src/lib/interactables.ts

@@ -66,8 +66,8 @@ const STAKE_HALF_W = 21;
 const STAKE_AGENT_GAP = 4;  // gap between agent and stake edge
 const STAKE_AGENT_OFFSET_X = STAKE_HALF_W + STAKE_AGENT_GAP; // 25px
 
-// Cushion: agent sits slightly above cushion center so body overlaps the cushion
-const CUSHION_SIT_OFFSET_Y = 2;
+// Cushion: agent sits on top of cushion — offset positions feet below cushion center
+const CUSHION_SIT_OFFSET_Y = 7;
 
 // ── Build interactable list from positions data ────────────
 

package/monitor/src/lib/ws-client.ts

@@ -1,13 +1,32 @@
 import { useMonitorStore } from './store.js';
 import type { MonitorEvent } from './types.js';
 
-const WS_URL = import.meta.env.VITE_MONITOR_WS_URL || 'ws://localhost:41242/monitor';
+/** Discover WS URL from the server's /monitor/info endpoint (proxied by Vite). */
+async function discoverWsUrl(): Promise<string> {
+  try {
+    const resp = await fetch('/monitor/info');
+    const data = await resp.json();
+    if (data.wsUrl) return data.wsUrl;
+  } catch { /* fallback */ }
+  return import.meta.env.VITE_MONITOR_WS_URL || 'ws://localhost:41242/monitor';
+}
 
 /** Shared persistent connection for both events and commands. */
 let sharedWs: WebSocket | null = null;
 
 export function connectWs(): () => void {
-  const ws = new WebSocket(WS_URL);
+  let cancelled = false;
+
+  discoverWsUrl().then((wsUrl) => {
+    if (cancelled) return;
+    const ws = new WebSocket(wsUrl);
+    setupWs(ws);
+  });
+
+  return () => { cancelled = true; if (sharedWs) sharedWs.close(); };
+}
+
+function setupWs(ws: WebSocket): void {
   sharedWs = ws;
 
   ws.addEventListener('open', () => {
@@ -32,8 +51,6 @@ export function connectWs(): () => void {
       console.error('[ws-client] bad message:', err);
     }
   });
-
-  return () => ws.close();
 }
 
 export function sendCommand(cmd: object): void {
@@ -41,11 +58,13 @@ export function sendCommand(cmd: object): void {
     sharedWs.send(JSON.stringify(cmd));
     return;
   }
-  // Fallback: open a one-shot connection
-  const ws = new WebSocket(WS_URL);
-  ws.addEventListener('open', () => {
-    ws.send(JSON.stringify(cmd));
-    ws.close();
+  // Fallback: discover URL and open a one-shot connection
+  discoverWsUrl().then((url) => {
+    const ws = new WebSocket(url);
+    ws.addEventListener('open', () => {
+      ws.send(JSON.stringify(cmd));
+      ws.close();
+    });
   });
 }
 

package/monitor/vite.config.ts

@@ -9,8 +9,14 @@ export default defineConfig({
   server: {
     port: 5173,
     proxy: {
-      // Optional: proxy A2A HTTP calls to framework (if needed)
-      // '/a2a': 'http://localhost:41241',
+      '/monitor/info': {
+        target: `http://localhost:${process.env.VITE_A2A_PORT || '41241'}`,
+        changeOrigin: true,
+      },
+      '/logs': {
+        target: `http://localhost:${process.env.VITE_A2A_PORT || '41241'}`,
+        changeOrigin: true,
+      },
     },
   },
 });

package/package.json

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