npm - agent-teams-dashboard - Versions diffs - 0.1.0 - Mend

agent-teams-dashboard 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (14) hide show

package/LICENSE +21 -0
package/README.md +80 -0
package/README.zh-TW.md +72 -0
package/bin/agent-teams-dashboard.js +8 -0
package/dist/assets/index-BwUrrF1R.css +1 -0
package/dist/assets/index-DEOAkXJf.js +49 -0
package/dist/index.html +13 -0
package/package.json +57 -0
package/server-dist/server/index.js +96 -0
package/server-dist/server/teamsApi.js +68 -0
package/server-dist/server/teamsCache.js +291 -0
package/server-dist/server/teamsWatcher.js +128 -0
package/server-dist/server/wsServer.js +62 -0
package/server-dist/src/types.js +1 -0

package/dist/index.html ADDED Viewed

@@ -0,0 +1,13 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Agent Teams Dashboard</title>
+    <script type="module" crossorigin src="/assets/index-DEOAkXJf.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-BwUrrF1R.css">
+  </head>
+  <body>
+    <div id="root"></div>
+  </body>
+</html>

package/package.json ADDED Viewed

@@ -0,0 +1,57 @@
+{
+  "name": "agent-teams-dashboard",
+  "version": "0.1.0",
+  "description": "Real-time monitoring dashboard for Claude Code agent teams",
+  "type": "module",
+  "author": "pingshian0131",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pingshian0131/agent-teams-dashboard.git"
+  },
+  "homepage": "https://github.com/pingshian0131/agent-teams-dashboard",
+  "keywords": [
+    "claude-code",
+    "agent",
+    "teams",
+    "dashboard",
+    "monitoring",
+    "websocket"
+  ],
+  "engines": {
+    "node": ">=20.11.0"
+  },
+  "bin": {
+    "agent-teams-dashboard": "bin/agent-teams-dashboard.js"
+  },
+  "files": [
+    "dist/",
+    "server-dist/",
+    "bin/",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "build:server": "tsc -p tsconfig.build-server.json",
+    "server": "tsx server/index.ts",
+    "preview": "vite preview",
+    "prepublishOnly": "npm run build && npm run build:server"
+  },
+  "dependencies": {
+    "react": "^19",
+    "react-dom": "^19",
+    "ws": "^8"
+  },
+  "devDependencies": {
+    "@types/node": "^22",
+    "@types/react": "^19",
+    "@types/react-dom": "^19",
+    "@types/ws": "^8",
+    "@vitejs/plugin-react": "^4",
+    "tsx": "^4",
+    "typescript": "^5",
+    "vite": "^6"
+  }
+}

package/server-dist/server/index.js ADDED Viewed

@@ -0,0 +1,96 @@
+import { createServer } from 'node:http';
+import { readFile } from 'node:fs/promises';
+import { join, extname } from 'node:path';
+import { existsSync } from 'node:fs';
+import { handleTeamsApi } from './teamsApi.js';
+import { initWebSocket } from './wsServer.js';
+import { startWatching } from './teamsWatcher.js';
+import * as cache from './teamsCache.js';
+const PORT = Number(process.env.PORT ?? 3001);
+const DIST_DIR = process.env.DIST_DIR ?? join(import.meta.dirname, '..', 'dist');
+const MIME_TYPES = {
+    '.html': 'text/html',
+    '.js': 'application/javascript',
+    '.css': 'text/css',
+    '.json': 'application/json',
+    '.png': 'image/png',
+    '.svg': 'image/svg+xml',
+    '.ico': 'image/x-icon',
+    '.woff': 'font/woff',
+    '.woff2': 'font/woff2',
+};
+async function serveStatic(url, res) {
+    if (!existsSync(DIST_DIR))
+        return false;
+    let filePath = join(DIST_DIR, url === '/' ? 'index.html' : url);
+    // SPA fallback: if file doesn't exist and it's not an API/asset route, serve index.html
+    if (!existsSync(filePath)) {
+        const ext = extname(filePath);
+        if (!ext) {
+            filePath = join(DIST_DIR, 'index.html');
+        }
+        else {
+            return false;
+        }
+    }
+    try {
+        const data = await readFile(filePath);
+        const ext = extname(filePath);
+        const mime = MIME_TYPES[ext] ?? 'application/octet-stream';
+        res.writeHead(200, { 'Content-Type': mime });
+        res.end(data);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+const server = createServer(async (req, res) => {
+    const url = req.url ?? '/';
+    // CORS headers for dev
+    res.setHeader('Access-Control-Allow-Origin', '*');
+    res.setHeader('Access-Control-Allow-Methods', 'GET, OPTIONS');
+    res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+    if (req.method === 'OPTIONS') {
+        res.writeHead(204);
+        res.end();
+        return;
+    }
+    // API routes
+    try {
+        const handled = await handleTeamsApi(req, res);
+        if (handled)
+            return;
+    }
+    catch (err) {
+        console.error('[api] Error handling request:', err);
+        res.writeHead(500, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'Internal server error' }));
+        return;
+    }
+    // Static file serving (production)
+    const served = await serveStatic(url, res);
+    if (served)
+        return;
+    // 404
+    res.writeHead(404, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ error: 'Not found' }));
+});
+async function start() {
+    // Initialize cache
+    await cache.refreshAll();
+    console.log(`[cache] Initial load complete`);
+    // Start HTTP server
+    server.listen(PORT, () => {
+        console.log(`[server] Listening on http://localhost:${PORT}`);
+    });
+    // Attach WebSocket
+    initWebSocket(server);
+    // Start file watchers
+    startWatching();
+    console.log('[watcher] File watchers started');
+}
+start().catch((err) => {
+    console.error('[server] Failed to start:', err);
+    process.exit(1);
+});

package/server-dist/server/teamsApi.js ADDED Viewed

@@ -0,0 +1,68 @@
+import * as cache from './teamsCache.js';
+function json(res, data, status = 200) {
+    res.writeHead(status, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify(data));
+}
+function notFound(res) {
+    json(res, { error: 'Not found' }, 404);
+}
+export async function handleTeamsApi(req, res) {
+    if (!req.url?.startsWith('/api/'))
+        return false;
+    const url = new URL(req.url, `http://${req.headers.host ?? 'localhost'}`);
+    const path = url.pathname;
+    // GET /api/snapshot
+    if (path === '/api/snapshot') {
+        json(res, cache.getSnapshot());
+        return true;
+    }
+    // GET /api/teams
+    if (path === '/api/teams') {
+        const snapshot = cache.getSnapshot();
+        json(res, snapshot.teams);
+        return true;
+    }
+    // GET /api/teams/:id/tasks
+    const tasksMatch = path.match(/^\/api\/teams\/([^/]+)\/tasks$/);
+    if (tasksMatch) {
+        const teamId = decodeURIComponent(tasksMatch[1]);
+        const snapshot = cache.getSnapshot();
+        const team = snapshot.teams.find((t) => t.config.name === teamId);
+        if (!team) {
+            notFound(res);
+            return true;
+        }
+        json(res, team.tasks);
+        return true;
+    }
+    // GET /api/teams/:id
+    const teamMatch = path.match(/^\/api\/teams\/([^/]+)$/);
+    if (teamMatch) {
+        const teamId = decodeURIComponent(teamMatch[1]);
+        const snapshot = cache.getSnapshot();
+        const team = snapshot.teams.find((t) => t.config.name === teamId);
+        if (!team) {
+            notFound(res);
+            return true;
+        }
+        json(res, team);
+        return true;
+    }
+    // GET /api/agents/:agentId/activity
+    const agentMatch = path.match(/^\/api\/agents\/([^/]+)\/activity$/);
+    if (agentMatch) {
+        const agentId = decodeURIComponent(agentMatch[1]);
+        let entries = cache.getAgentActivity(agentId);
+        const limitParam = url.searchParams.get('limit');
+        if (limitParam) {
+            const limit = parseInt(limitParam, 10);
+            if (!isNaN(limit) && limit > 0) {
+                entries = entries.slice(-limit);
+            }
+        }
+        json(res, entries);
+        return true;
+    }
+    notFound(res);
+    return true;
+}

package/server-dist/server/teamsCache.js ADDED Viewed

@@ -0,0 +1,291 @@
+import { readdir, readFile, stat } from 'node:fs/promises';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { EventEmitter } from 'node:events';
+const CLAUDE_DIR = join(homedir(), '.claude');
+const TEAMS_DIR = join(CLAUDE_DIR, 'teams');
+const TASKS_DIR = join(CLAUDE_DIR, 'tasks');
+const PROJECTS_DIR = join(CLAUDE_DIR, 'projects');
+const MAX_ENTRIES_PER_AGENT = 200;
+// In-memory caches
+const teams = new Map();
+const tasks = new Map();
+const agentEntries = new Map();
+const agentOffsets = new Map();
+const teamFileMtimes = new Map(); // team name -> latest mtime (ms)
+export const onChange = new EventEmitter();
+// --- Helpers ---
+async function safeReaddir(dir) {
+    try {
+        return await readdir(dir);
+    }
+    catch {
+        return [];
+    }
+}
+async function safeReadFile(path) {
+    try {
+        return await readFile(path, 'utf-8');
+    }
+    catch {
+        return null;
+    }
+}
+async function safeFileStat(path) {
+    try {
+        return await stat(path);
+    }
+    catch {
+        return null;
+    }
+}
+// --- Teams ---
+export async function refreshTeams() {
+    const teamDirs = await safeReaddir(TEAMS_DIR);
+    const currentNames = new Set();
+    for (const dir of teamDirs) {
+        const configPath = join(TEAMS_DIR, dir, 'config.json');
+        const raw = await safeReadFile(configPath);
+        if (!raw)
+            continue;
+        try {
+            const parsed = JSON.parse(raw);
+            const config = {
+                name: parsed.name ?? dir,
+                members: Array.isArray(parsed.members)
+                    ? parsed.members.map((m) => ({
+                        name: m.name ?? '',
+                        agentId: m.agentId ?? '',
+                        agentType: m.agentType ?? '',
+                    }))
+                    : [],
+            };
+            teams.set(config.name, config);
+            currentNames.add(config.name);
+            // Track config file mtime
+            const configStat = await safeFileStat(configPath);
+            if (configStat) {
+                const prev = teamFileMtimes.get(config.name) ?? 0;
+                if (configStat.mtimeMs > prev) {
+                    teamFileMtimes.set(config.name, configStat.mtimeMs);
+                }
+            }
+        }
+        catch {
+            // skip malformed config
+        }
+    }
+    // Remove teams that no longer exist on disk
+    for (const name of teams.keys()) {
+        if (!currentNames.has(name)) {
+            teams.delete(name);
+            teamFileMtimes.delete(name);
+        }
+    }
+}
+// --- Tasks ---
+export async function refreshTasks(teamId) {
+    const taskDir = join(TASKS_DIR, teamId);
+    const files = await safeReaddir(taskDir);
+    const teamTasks = [];
+    for (const file of files) {
+        if (!file.endsWith('.json'))
+            continue;
+        const filePath = join(taskDir, file);
+        const raw = await safeReadFile(filePath);
+        if (!raw)
+            continue;
+        try {
+            const parsed = JSON.parse(raw);
+            teamTasks.push({
+                id: String(parsed.id ?? ''),
+                subject: parsed.subject ?? '',
+                description: parsed.description ?? '',
+                activeForm: parsed.activeForm ?? '',
+                status: parsed.status ?? 'pending',
+                blocks: Array.isArray(parsed.blocks) ? parsed.blocks : [],
+                blockedBy: Array.isArray(parsed.blockedBy) ? parsed.blockedBy : [],
+                owner: parsed.owner,
+            });
+            // Track task file mtime for lastActivity
+            const taskStat = await safeFileStat(filePath);
+            if (taskStat) {
+                const prev = teamFileMtimes.get(teamId) ?? 0;
+                if (taskStat.mtimeMs > prev) {
+                    teamFileMtimes.set(teamId, taskStat.mtimeMs);
+                }
+            }
+        }
+        catch {
+            // skip malformed task
+        }
+    }
+    // Sort by numeric id
+    teamTasks.sort((a, b) => Number(a.id) - Number(b.id));
+    tasks.set(teamId, teamTasks);
+}
+async function refreshAllTasks() {
+    // Refresh tasks for known teams
+    for (const name of teams.keys()) {
+        await refreshTasks(name);
+    }
+    // Also check tasks dir for any team dirs not yet in teams map
+    const taskDirs = await safeReaddir(TASKS_DIR);
+    for (const dir of taskDirs) {
+        if (!tasks.has(dir)) {
+            await refreshTasks(dir);
+        }
+    }
+}
+// --- Agent JSONL scanning ---
+export async function scanAgentJsonl() {
+    const projectDirs = await safeReaddir(PROJECTS_DIR);
+    for (const projDir of projectDirs) {
+        const projPath = join(PROJECTS_DIR, projDir);
+        const sessionDirs = await safeReaddir(projPath);
+        for (const sessionDir of sessionDirs) {
+            const subagentsDir = join(projPath, sessionDir, 'subagents');
+            const files = await safeReaddir(subagentsDir);
+            for (const file of files) {
+                if (!file.startsWith('agent-') || !file.endsWith('.jsonl'))
+                    continue;
+                const filePath = join(subagentsDir, file);
+                await readNewEntries(filePath);
+            }
+        }
+    }
+}
+async function readNewEntries(filePath) {
+    const fileStat = await safeFileStat(filePath);
+    if (!fileStat)
+        return;
+    const currentOffset = agentOffsets.get(filePath) ?? 0;
+    const fileSize = fileStat.size;
+    if (fileSize <= currentOffset)
+        return;
+    const raw = await safeReadFile(filePath);
+    if (!raw)
+        return;
+    // Read only from the offset position
+    const newContent = raw.slice(currentOffset);
+    agentOffsets.set(filePath, fileSize);
+    const lines = newContent.split('\n').filter(Boolean);
+    for (const line of lines) {
+        try {
+            const parsed = JSON.parse(line);
+            const entry = {
+                agentId: parsed.agentId ?? '',
+                slug: parsed.slug ?? '',
+                sessionId: parsed.sessionId ?? '',
+                type: parsed.type ?? 'assistant',
+                message: {
+                    role: parsed.message?.role ?? '',
+                    content: Array.isArray(parsed.message?.content)
+                        ? parsed.message.content
+                        : typeof parsed.message?.content === 'string'
+                            ? [{ type: 'text', text: parsed.message.content }]
+                            : [],
+                    model: parsed.message?.model,
+                },
+                timestamp: parsed.timestamp ?? '',
+            };
+            if (!entry.agentId)
+                continue;
+            let entries = agentEntries.get(entry.agentId);
+            if (!entries) {
+                entries = [];
+                agentEntries.set(entry.agentId, entries);
+            }
+            entries.push(entry);
+            // Trim to max entries
+            if (entries.length > MAX_ENTRIES_PER_AGENT) {
+                const excess = entries.length - MAX_ENTRIES_PER_AGENT;
+                entries.splice(0, excess);
+            }
+        }
+        catch {
+            // skip malformed line
+        }
+    }
+}
+// --- Snapshot assembly ---
+function buildTeamOverview(teamName) {
+    const config = teams.get(teamName) ?? { name: teamName, members: [] };
+    const teamTasks = tasks.get(teamName) ?? [];
+    const taskStats = {
+        total: teamTasks.length,
+        pending: teamTasks.filter(t => t.status === 'pending').length,
+        inProgress: teamTasks.filter(t => t.status === 'in_progress').length,
+        completed: teamTasks.filter(t => t.status === 'completed').length,
+    };
+    // Build agentSlugs: map agentId -> slug from agentEntries
+    const agentSlugs = {};
+    for (const member of config.members) {
+        // Look for agent entries matching this member's agentId
+        const entries = agentEntries.get(member.agentId);
+        if (entries && entries.length > 0) {
+            agentSlugs[member.agentId] = entries[entries.length - 1].slug;
+        }
+        // Also try short agentId (before @)
+        const shortId = member.agentId.split('@')[0];
+        if (shortId !== member.agentId) {
+            const shortEntries = agentEntries.get(shortId);
+            if (shortEntries && shortEntries.length > 0) {
+                agentSlugs[member.agentId] = shortEntries[shortEntries.length - 1].slug;
+            }
+        }
+    }
+    // Find last activity timestamp from agent JSONL entries
+    let lastActivity = '';
+    for (const member of config.members) {
+        const entries = agentEntries.get(member.agentId) ?? agentEntries.get(member.agentId.split('@')[0]);
+        if (entries && entries.length > 0) {
+            const ts = entries[entries.length - 1].timestamp;
+            if (ts > lastActivity)
+                lastActivity = ts;
+        }
+    }
+    // Fallback: use file modification times (config + task files)
+    if (!lastActivity) {
+        const mtime = teamFileMtimes.get(teamName);
+        if (mtime) {
+            lastActivity = new Date(mtime).toISOString();
+        }
+    }
+    return { config, tasks: teamTasks, taskStats, agentSlugs, lastActivity };
+}
+export function getSnapshot() {
+    const teamOverviews = [];
+    const matchedAgentIds = new Set();
+    for (const teamName of teams.keys()) {
+        const overview = buildTeamOverview(teamName);
+        teamOverviews.push(overview);
+        for (const member of overview.config.members) {
+            matchedAgentIds.add(member.agentId);
+            matchedAgentIds.add(member.agentId.split('@')[0]);
+        }
+    }
+    // Find unmatched agents
+    const unmatchedAgents = [];
+    for (const [agentId, entries] of agentEntries) {
+        if (!matchedAgentIds.has(agentId) && entries.length > 0) {
+            const last = entries[entries.length - 1];
+            unmatchedAgents.push({
+                agentId,
+                slug: last.slug,
+                sessionId: last.sessionId,
+            });
+        }
+    }
+    return { teams: teamOverviews, unmatchedAgents };
+}
+// --- Query ---
+export function getAgentActivity(agentId) {
+    return agentEntries.get(agentId) ?? [];
+}
+// --- Full refresh ---
+export async function refreshAll() {
+    await refreshTeams();
+    await refreshAllTasks();
+    await scanAgentJsonl();
+}

package/server-dist/server/teamsWatcher.js ADDED Viewed

@@ -0,0 +1,128 @@
+import { watch, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import * as cache from './teamsCache.js';
+const CLAUDE_DIR = join(homedir(), '.claude');
+const TEAMS_DIR = join(CLAUDE_DIR, 'teams');
+const TASKS_DIR = join(CLAUDE_DIR, 'tasks');
+const DEBOUNCE_MS = 200;
+const JSONL_POLL_MS = 2000;
+const DIR_CHECK_MS = 5000;
+let tasksWatcher = null;
+let teamsWatcher = null;
+let jsonlTimer = null;
+let dirCheckTimer = null;
+// --- Debounce helper ---
+function debounce(fn, ms) {
+    let timer = null;
+    return ((...args) => {
+        if (timer)
+            clearTimeout(timer);
+        timer = setTimeout(() => fn(...args), ms);
+    });
+}
+// --- Tasks watcher ---
+function startTasksWatcher() {
+    if (tasksWatcher)
+        return;
+    if (!existsSync(TASKS_DIR))
+        return;
+    const onTaskChange = debounce(async (_event, filename) => {
+        if (!filename) {
+            // Full refresh if no filename
+            for (const team of (await import('./teamsCache.js')).getSnapshot().teams) {
+                await cache.refreshTasks(team.config.name);
+            }
+        }
+        else {
+            // filename could be "teamName/1.json" or just "teamName"
+            const teamId = filename.split('/')[0];
+            if (teamId) {
+                await cache.refreshTasks(teamId);
+            }
+        }
+        cache.onChange.emit('change');
+    }, DEBOUNCE_MS);
+    try {
+        tasksWatcher = watch(TASKS_DIR, { recursive: true }, onTaskChange);
+        tasksWatcher.on('error', () => {
+            tasksWatcher?.close();
+            tasksWatcher = null;
+        });
+    }
+    catch {
+        // watch not supported or dir not accessible
+    }
+}
+// --- Teams watcher ---
+function startTeamsWatcher() {
+    if (teamsWatcher)
+        return;
+    if (!existsSync(TEAMS_DIR))
+        return;
+    const onTeamChange = debounce(async () => {
+        await cache.refreshTeams();
+        // Also refresh tasks in case new team appeared
+        for (const team of cache.getSnapshot().teams) {
+            await cache.refreshTasks(team.config.name);
+        }
+        cache.onChange.emit('change');
+    }, DEBOUNCE_MS);
+    try {
+        teamsWatcher = watch(TEAMS_DIR, { recursive: true }, onTeamChange);
+        teamsWatcher.on('error', () => {
+            teamsWatcher?.close();
+            teamsWatcher = null;
+        });
+    }
+    catch {
+        // watch not supported
+    }
+}
+// --- Directory existence poller (for dirs that may not yet exist) ---
+function startDirCheckPoller() {
+    dirCheckTimer = setInterval(() => {
+        if (!tasksWatcher && existsSync(TASKS_DIR)) {
+            startTasksWatcher();
+        }
+        if (!teamsWatcher && existsSync(TEAMS_DIR)) {
+            startTeamsWatcher();
+        }
+        // Stop polling once both watchers are up
+        if (tasksWatcher && teamsWatcher && dirCheckTimer) {
+            clearInterval(dirCheckTimer);
+            dirCheckTimer = null;
+        }
+    }, DIR_CHECK_MS);
+}
+// --- Agent JSONL poller ---
+function startJsonlPoller() {
+    jsonlTimer = setInterval(async () => {
+        await cache.scanAgentJsonl();
+        cache.onChange.emit('change');
+    }, JSONL_POLL_MS);
+}
+// --- Public API ---
+export function startWatching() {
+    startTasksWatcher();
+    startTeamsWatcher();
+    startJsonlPoller();
+    // If either dir doesn't exist yet, poll for them
+    if (!tasksWatcher || !teamsWatcher) {
+        startDirCheckPoller();
+    }
+}
+export function stopWatching() {
+    tasksWatcher?.close();
+    tasksWatcher = null;
+    teamsWatcher?.close();
+    teamsWatcher = null;
+    if (jsonlTimer) {
+        clearInterval(jsonlTimer);
+        jsonlTimer = null;
+    }
+    if (dirCheckTimer) {
+        clearInterval(dirCheckTimer);
+        dirCheckTimer = null;
+    }
+}