claude-live 0.4.8 → 1.1.1

package/server/index.js

@@ -1,288 +0,0 @@
-import express from 'express'
-import { createHash, randomUUID } from 'crypto'
-import { createServer as createHttpServer } from 'http'
-import { fileURLToPath } from 'url'
-import { join, dirname } from 'path'
-
-const __dirname = dirname(fileURLToPath(import.meta.url))
-const DIST_DIR = join(__dirname, '../client/dist')
-const EVENTS_PER_SESSION = 50  // rolling buffer per session
-const SESSION_TIMEOUT_MS = 11 * 60 * 1000  // 11 minutes (server-side cleanup)
-const HEARTBEAT_MS = 15000
-
-// ── Ported from client constants/nodeKeys (JS) ──────────────────────────────
-
-const TOOL_COLOR_HEX = {
-  Read: '#4ade80', Edit: '#60a5fa', Write: '#60a5fa',
-  Bash: '#f59e0b', Grep: '#a78bfa', Glob: '#a78bfa',
-  WebFetch: '#f472b6', Stop: '#888888', Notification: '#34d399',
-}
-const DEFAULT_HEX = '#555555'
-const FILE_TOOLS = new Set(['Read', 'Edit', 'Write', 'Glob', 'Grep'])
-
-function nodeKeyFor(event) {
-  const t = event.tool_name
-  if (!t) {
-    if (event.hook_event_name === 'Stop') return 'session:stop'
-    if (event.hook_event_name === 'Notification') {
-      const msg = event.tool_input?.message || ''
-      return `notification:${msg.slice(0, 20)}`
-    }
-    return null
-  }
-  const input = event.tool_input || {}
-  if (FILE_TOOLS.has(t)) {
-    const fp = input.file_path || input.path || null
-    return fp ? `file:${fp}` : null
-  }
-  if (t === 'Bash') return `bash:${input.command || ''}`
-  if (t === 'WebFetch') {
-    try { return `web:${new URL(input.url || '').hostname}` } catch { return 'web:unknown' }
-  }
-  return `tool:${t}`
-}
-
-function nodeTypeFor(event) {
-  const t = event.tool_name
-  if (FILE_TOOLS.has(t || '')) return 'file'
-  if (t === 'Bash') return 'bash'
-  if (t === 'WebFetch') return 'web'
-  if (event.hook_event_name === 'Stop') return 'stop'
-  if (event.hook_event_name === 'Notification') return 'notification'
-  return 'tool'
-}
-
-function labelFor(event) {
-  const t = event.tool_name
-  const input = event.tool_input || {}
-  if (FILE_TOOLS.has(t || '')) {
-    const fp = input.file_path || input.path || ''
-    return fp.split('/').pop() || fp
-  }
-  if (t === 'Bash') return `$ ${(input.command || '').slice(0, 22)}`
-  if (t === 'WebFetch') { try { return `↗ ${new URL(input.url || '').hostname}` } catch { return '↗ web' } }
-  if (event.hook_event_name === 'Stop') return '✓ done'
-  if (event.hook_event_name === 'Notification') return (input.message || 'notification').slice(0, 24)
-  return t || event.hook_event_name || '?'
-}
-
-// ── State snapshot computation ───────────────────────────────────────────────
-
-// Compute a lightweight state snapshot from a session's event buffer.
-// Returns null if the session has no events.
-function computeSessionSnapshot(session_id, events) {
-  if (events.length === 0) return null
-
-  let label = null
-  let cwd = null
-  let stopping = false
-  let eventCount = events.length
-
-  // file nodes: persistent, grow with each touch
-  const fileNodes = new Map()  // key → { key, nodeType, label, colorHex, baseRadius }
-  // ephemeral keys seen in recent N events (they decay fast so only show recent ones)
-  const RECENT_N = 15
-  const recentEphemeralKeys = new Set()
-
-  for (let i = 0; i < events.length; i++) {
-    const event = events[i]
-
-    if (event.cwd) cwd = event.cwd
-    if (cwd && (!label || label.length <= 8)) {
-      const parts = cwd.split('/').filter(Boolean)
-      label = parts[parts.length - 1] || null
-    }
-
-    if (event.hook_event_name === 'Stop') {
-      stopping = true
-    } else if (event.hook_event_name !== 'SessionEnd') {
-      stopping = false
-    }
-
-    const key = nodeKeyFor(event)
-    if (!key) continue
-    const type = nodeTypeFor(event)
-    const isFile = type === 'file'
-    const colorHex = TOOL_COLOR_HEX[event.tool_name || event.hook_event_name] ?? DEFAULT_HEX
-
-    if (isFile) {
-      if (fileNodes.has(key)) {
-        fileNodes.get(key).baseRadius = Math.min(8, fileNodes.get(key).baseRadius + 0.3)
-      } else {
-        fileNodes.set(key, { key, nodeType: type, label: labelFor(event), colorHex, baseRadius: 2.5 })
-      }
-    } else if (i >= events.length - RECENT_N) {
-      recentEphemeralKeys.add(key)
-    }
-  }
-
-  // Build node list: files first, then recent ephemerals
-  const nodes = [...fileNodes.values()]
-
-  // Add recent ephemerals (not already in files)
-  const fileKeySet = new Set(fileNodes.keys())
-  for (let i = Math.max(0, events.length - RECENT_N); i < events.length; i++) {
-    const event = events[i]
-    const key = nodeKeyFor(event)
-    if (!key || fileKeySet.has(key)) continue
-    const type = nodeTypeFor(event)
-    const colorHex = TOOL_COLOR_HEX[event.tool_name || event.hook_event_name] ?? DEFAULT_HEX
-    if (!nodes.find(n => n.key === key)) {
-      nodes.push({ key, nodeType: type, label: labelFor(event), colorHex, baseRadius: 4 })
-    }
-  }
-
-  // Ring assignment is handled by the client (server just sends node data)
-  return {
-    session_id,
-    label: label || session_id.slice(0, 8),
-    cwd,
-    stopping,
-    eventCount,
-    nodes,  // [{ key, nodeType, label, colorHex, baseRadius }]
-  }
-}
-
-// ── Server ───────────────────────────────────────────────────────────────────
-
-function makeSessionId(ip, ts) {
-  return 'unknown-' + createHash('sha1').update(ip + ts).digest('hex').slice(0, 8)
-}
-
-function normalizeEvent(raw, remoteIp) {
-  const session_id = raw.session_id?.trim() || makeSessionId(remoteIp, Date.now().toString())
-  return {
-    id: randomUUID(),
-    session_id,
-    timestamp: Date.now(),
-    hook_event_name: raw.hook_event_name ?? null,
-    tool_name: raw.tool_name ?? null,
-    tool_input: raw.tool_input ?? null,
-    tool_response: raw.tool_response ?? null,
-    agent_id: raw.agent_id ?? null,
-    agent_type: raw.agent_type ?? null,
-    cwd: raw.cwd ?? null,
-    error: raw.error ?? null,
-    tool_use_id: raw.tool_use_id ?? null,
-    prompt: raw.prompt ?? null,
-    model: raw.model ?? null,
-    source: raw.source ?? null,
-    reason: raw.reason ?? null,
-    permission_mode: raw.permission_mode ?? null,
-    is_interrupt: raw.is_interrupt ?? null,
-    trigger: raw.trigger ?? null,
-    compact_summary: raw.compact_summary ?? null,
-    last_assistant_message: raw.last_assistant_message ?? null,
-    notification_type: raw.notification_type ?? null,
-    title: raw.title ?? null,
-    agent_transcript_path: raw.agent_transcript_path ?? null,
-    file_path_loaded: raw.file_path ?? null,
-    memory_type: raw.memory_type ?? null,
-  }
-}
-
-export function createServer({ port = 43451 } = {}) {
-  const app = express()
-  const clients = new Set()
-  const sessionBuffers = new Map()  // session_id -> { events: [], lastEventTime: number }
-
-  function getOrCreateSession(sessionId) {
-    if (!sessionBuffers.has(sessionId)) {
-      sessionBuffers.set(sessionId, { events: [], lastEventTime: Date.now() })
-    }
-    return sessionBuffers.get(sessionId)
-  }
-
-  function cleanupStaleSessions() {
-    const now = Date.now()
-    for (const [sid, session] of sessionBuffers) {
-      if (now - session.lastEventTime > SESSION_TIMEOUT_MS) {
-        sessionBuffers.delete(sid)
-      }
-    }
-  }
-
-  app.use(express.json())
-
-  app.post('/hook', (req, res) => {
-    const raw = req.body
-    if (!raw || typeof raw !== 'object') return res.status(400).json({ error: 'invalid json' })
-    const event = normalizeEvent(raw, req.ip)
-    const session = getOrCreateSession(event.session_id)
-    session.events.push(event)
-    session.lastEventTime = Date.now()
-    if (session.events.length > EVENTS_PER_SESSION) session.events.shift()
-
-    const data = `data: ${JSON.stringify(event)}\n\n`
-    for (const client of clients) {
-      try { client.write(data) } catch { clients.delete(client) }
-    }
-    res.json({ ok: true })
-  })
-
-  app.get('/events', (req, res) => {
-    res.setHeader('Content-Type', 'text/event-stream')
-    res.setHeader('Cache-Control', 'no-cache')
-    res.setHeader('Connection', 'keep-alive')
-    res.flushHeaders()
-
-    // Send state snapshot instead of replaying raw events
-    const sessions = []
-    for (const [sid, session] of sessionBuffers) {
-      const snap = computeSessionSnapshot(sid, session.events)
-      if (snap) sessions.push(snap)
-    }
-    res.write(`data: ${JSON.stringify({ type: 'state_snapshot', sessions })}\n\n`)
-
-    clients.add(res)
-    const heartbeat = setInterval(() => {
-      try { res.write(': heartbeat\n\n') } catch { clients.delete(res); clearInterval(heartbeat) }
-    }, HEARTBEAT_MS)
-    req.on('close', () => { clients.delete(res); clearInterval(heartbeat) })
-    res.on('error', () => { clients.delete(res); clearInterval(heartbeat) })
-  })
-
-  // expose session buffers for tests
-  app.get('/buffer', (req, res) => {
-    const allEvents = []
-    for (const session of sessionBuffers.values()) {
-      allEvents.push(...session.events)
-    }
-    res.json(allEvents)
-  })
-
-  // cleanup stale sessions periodically
-  setInterval(cleanupStaleSessions, 60000)
-
-  // serve static build
-  app.use(express.static(DIST_DIR))
-
-  return new Promise((resolve, reject) => {
-    const httpServer = createHttpServer(app)
-    httpServer.listen(port, () => {
-      const actualPort = httpServer.address().port
-      resolve({ server: httpServer, port: actualPort, app })
-    })
-    httpServer.on('error', reject)
-  })
-}
-
-// Run standalone
-if (process.argv[1] === fileURLToPath(import.meta.url)) {
-  const desiredPort = parseInt(process.env.PORT || '43451', 10)
-  let p = desiredPort
-  const tryStart = async () => {
-    try {
-      const { port } = await createServer({ port: p })
-      console.log(`claude-live server listening on http://localhost:${port}`)
-      if (p !== desiredPort) {
-        console.log(`(port ${desiredPort} was in use, using ${port} instead)`)
-        console.log(`Update your hook URL to: http://localhost:${port}/hook`)
-      }
-    } catch (e) {
-      if (e.code === 'EADDRINUSE') { p++; tryStart() }
-      else { console.error(e); process.exit(1) }
-    }
-  }
-  tryStart()
-}

package/test-agent-animations-long.js

@@ -1,144 +0,0 @@
-#!/usr/bin/env node
-// Extended test with more agents and longer animation sequence
-
-import http from 'http';
-import { URL } from 'url';
-
-const SERVER = 'http://localhost:43453';
-const SESSION_ID = 'test-session-' + Date.now();
-
-function sendHook(eventName, data = {}) {
-  return new Promise((resolve, reject) => {
-    const payload = JSON.stringify({
-      hook_event_name: eventName,
-      session_id: SESSION_ID,
-      timestamp: Date.now(),
-      ...data
-    });
-
-    const url = new URL('/hook', SERVER);
-    const options = {
-      hostname: url.hostname,
-      port: url.port || 80,
-      path: url.pathname,
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'Content-Length': Buffer.byteLength(payload)
-      }
-    };
-
-    const req = http.request(options, (res) => {
-      resolve(`${eventName}: ${res.statusCode}`);
-    });
-
-    req.on('error', reject);
-    req.write(payload);
-    req.end();
-  });
-}
-
-async function wait(ms) {
-  return new Promise(r => setTimeout(r, ms));
-}
-
-async function agentAction(agentId, tool, filePath, delay = 800) {
-  await sendHook('PreToolUse', {
-    tool_name: tool,
-    tool_input: { file_path: filePath, pattern: filePath },
-    agent_id: agentId
-  });
-  await wait(delay);
-  await sendHook('PostToolUse', {
-    tool_name: tool,
-    tool_input: { file_path: filePath, pattern: filePath },
-    agent_id: agentId
-  });
-}
-
-async function testAgentAnimationsLong() {
-  console.log('🚀 Extended Agent Animation Test (4 agents, many actions)\n');
-
-  try {
-    // Spawn 4 agents
-    console.log('📍 Spawning 4 agents...');
-    for (let i = 1; i <= 4; i++) {
-      await sendHook('SubagentStart', {
-        agent_id: `agent-${i}`,
-        agent_type: 'claude-opus-4-6'
-      });
-      console.log(`   Agent ${i} spawned`);
-      await wait(300);
-    }
-
-    await wait(1000);
-
-    // Agent 1: Multiple reads
-    console.log('\n📖 Agent 1: Multiple read operations...');
-    await agentAction('agent-1', 'Read', 'client/src/store.ts', 1000);
-    await wait(500);
-    await agentAction('agent-1', 'Read', 'client/src/types.ts', 1000);
-    await wait(500);
-    await agentAction('agent-1', 'Read', 'README.md', 1000);
-
-    // Agent 2: Grep operations
-    console.log('\n🔎 Agent 2: Search operations...');
-    await agentAction('agent-2', 'Grep', 'agentPositionMap', 1000);
-    await wait(500);
-    await agentAction('agent-2', 'Grep', 'getAnimationOrigin', 1000);
-
-    // Agent 3: Glob operations
-    console.log('\n📂 Agent 3: File matching operations...');
-    await agentAction('agent-3', 'Glob', 'client/src/**/*.tsx', 1200);
-    await wait(600);
-    await agentAction('agent-3', 'Glob', '**/*.ts', 1200);
-
-    // Agent 4: Mixed operations
-    console.log('\n🔄 Agent 4: Mixed operations...');
-    await agentAction('agent-4', 'Read', 'package.json', 1000);
-    await wait(500);
-    await agentAction('agent-4', 'Grep', 'vite', 1000);
-
-    await wait(1000);
-
-    // More concurrent-looking operations
-    console.log('\n⚡ Agents 1 & 2: Concurrent operations...');
-    await Promise.all([
-      agentAction('agent-1', 'Read', 'client/src/canvas/renderer.ts', 1200),
-      agentAction('agent-2', 'Grep', 'projectile', 1200)
-    ]);
-
-    await wait(800);
-
-    // Agent 3 continues
-    console.log('\n📂 Agent 3: More operations...');
-    await agentAction('agent-3', 'Glob', 'docs/**/*.md', 1200);
-
-    await wait(1000);
-
-    // Final operations before termination
-    console.log('\n🎬 Final actions before termination...');
-    await agentAction('agent-1', 'Read', 'client/src/canvas/graph.ts', 1000);
-    await wait(400);
-    await agentAction('agent-4', 'Grep', 'animation', 1000);
-    await wait(400);
-    await agentAction('agent-2', 'Read', '.gitignore', 1000);
-
-    await wait(1500);
-
-    // Terminate agents one by one
-    console.log('\n🛑 Terminating agents...');
-    for (let i = 1; i <= 4; i++) {
-      await sendHook('SubagentStop', { agent_id: `agent-${i}` });
-      console.log(`   Agent ${i} terminated (star fading out)`);
-      await wait(600);
-    }
-
-    console.log('\n✅ Extended test complete! All agents have terminated.\n');
-  } catch (err) {
-    console.error('❌ Error:', err.message);
-    process.exit(1);
-  }
-}
-
-testAgentAnimationsLong();

package/test-agent-animations.js

@@ -1,126 +0,0 @@
-#!/usr/bin/env node
-// Test script to trigger agent animation routing by sending hooks to claude-live server
-
-import http from 'http';
-import { URL } from 'url';
-
-const SERVER = 'http://localhost:43453';
-const SESSION_ID = 'test-session-' + Date.now();
-
-function sendHook(eventName, data = {}) {
-  return new Promise((resolve, reject) => {
-    const payload = JSON.stringify({
-      hook_event_name: eventName,
-      session_id: SESSION_ID,
-      timestamp: Date.now(),
-      ...data
-    });
-
-    const url = new URL('/hook', SERVER);
-    const options = {
-      hostname: url.hostname,
-      port: url.port || 80,
-      path: url.pathname,
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'Content-Length': Buffer.byteLength(payload)
-      }
-    };
-
-    const req = http.request(options, (res) => {
-      resolve(`${eventName}: ${res.statusCode}`);
-    });
-
-    req.on('error', reject);
-    req.write(payload);
-    req.end();
-  });
-}
-
-async function testAgentAnimations() {
-  console.log('🚀 Testing Agent Animation Routing...\n');
-
-  try {
-    // Agent 1: Spawn and read
-    console.log('📍 Agent 1: Spawning...');
-    await sendHook('SubagentStart', {
-      agent_id: 'agent-1',
-      agent_type: 'claude-opus-4-6'
-    });
-    await new Promise(r => setTimeout(r, 500));
-
-    console.log('📖 Agent 1: Reading file...');
-    await sendHook('PreToolUse', {
-      tool_name: 'Read',
-      tool_input: { file_path: 'client/src/store.ts' },
-      agent_id: 'agent-1'
-    });
-    await new Promise(r => setTimeout(r, 300));
-
-    await sendHook('PostToolUse', {
-      tool_name: 'Read',
-      tool_input: { file_path: 'client/src/store.ts' },
-      agent_id: 'agent-1'
-    });
-    await new Promise(r => setTimeout(r, 500));
-
-    // Agent 2: Spawn and read
-    console.log('📍 Agent 2: Spawning...');
-    await sendHook('SubagentStart', {
-      agent_id: 'agent-2',
-      agent_type: 'claude-opus-4-6'
-    });
-    await new Promise(r => setTimeout(r, 500));
-
-    console.log('📖 Agent 2: Reading file...');
-    await sendHook('PreToolUse', {
-      tool_name: 'Read',
-      tool_input: { file_path: 'README.md' },
-      agent_id: 'agent-2'
-    });
-    await new Promise(r => setTimeout(r, 300));
-
-    await sendHook('PostToolUse', {
-      tool_name: 'Read',
-      tool_input: { file_path: 'README.md' },
-      agent_id: 'agent-2'
-    });
-    await new Promise(r => setTimeout(r, 500));
-
-    // Agent 1: Glob operation
-    console.log('🔍 Agent 1: Globbing...');
-    await sendHook('PreToolUse', {
-      tool_name: 'Glob',
-      tool_input: { pattern: 'client/src/**/*.tsx' },
-      agent_id: 'agent-1'
-    });
-    await new Promise(r => setTimeout(r, 300));
-
-    await sendHook('PostToolUse', {
-      tool_name: 'Glob',
-      tool_input: { pattern: 'client/src/**/*.tsx' },
-      agent_id: 'agent-1'
-    });
-    await new Promise(r => setTimeout(r, 500));
-
-    // Terminate agents
-    console.log('🛑 Agent 1: Terminating...');
-    await sendHook('SubagentStop', {
-      agent_id: 'agent-1'
-    });
-    await new Promise(r => setTimeout(r, 300));
-
-    console.log('🛑 Agent 2: Terminating...');
-    await sendHook('SubagentStop', {
-      agent_id: 'agent-2'
-    });
-
-    console.log('\n✅ Test complete! Check http://localhost:43451 for animations.\n');
-  } catch (err) {
-    console.error('❌ Error:', err.message);
-    process.exit(1);
-  }
-}
-
-testAgentAnimations();

package/test-agents.js

@@ -1,61 +0,0 @@
-import fs from "fs";
-import path from "path";
-import { fileURLToPath } from "url";
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-
-// Get all files in current directory
-function getAllFiles(dir = ".") {
-  try {
-    return fs
-      .readdirSync(dir)
-      .filter((f) => fs.statSync(path.join(dir, f)).isFile())
-      .map((f) => path.join(dir, f));
-  } catch {
-    return [];
-  }
-}
-
-// Pick random items from array
-function pickRandom(arr, count) {
-  const shuffled = [...arr].sort(() => Math.random() - 0.5);
-  return shuffled.slice(0, Math.min(count, arr.length));
-}
-
-// Agent function
-async function agent(id, interval = 2000) {
-  console.log(`[Agent ${id}] Started`);
-
-  const tick = () => {
-    const allFiles = getAllFiles();
-    const randomCount = Math.floor(Math.random() * 3) + 1; // 1-3 files
-    const randomFiles = pickRandom(allFiles, randomCount);
-
-    console.log(
-      `[Agent ${id}] Processing ${randomFiles.length} files:`,
-      randomFiles.join(", ")
-    );
-
-    // Simulate work
-    randomFiles.forEach((file) => {
-      try {
-        const stats = fs.statSync(file);
-        console.log(`  ├─ ${file}: ${stats.size} bytes`);
-      } catch {
-        console.log(`  ├─ ${file}: (error reading)`);
-      }
-    });
-  };
-
-  // Run immediately and then every interval
-  tick();
-  setInterval(tick, interval);
-}
-
-// Start 3 agents
-console.log("Starting 3 test agents...\n");
-agent(1);
-agent(2);
-agent(3);
-
-console.log("\nPress Ctrl+C to stop\n");

package/tests/server.test.js

@@ -1,48 +0,0 @@
-// tests/server.test.js
-import { describe, it, expect, beforeAll, afterAll } from 'vitest'
-import { createServer } from '../server/index.js'
-
-describe('SSE server', () => {
-  let server, port
-
-  beforeAll(async () => {
-    ({ server, port } = await createServer({ port: 0 })) // port 0 = OS assigns
-  })
-
-  afterAll(() => server.close())
-
-  it('returns 200 on POST /hook with valid JSON', async () => {
-    const res = await fetch(`http://localhost:${port}/hook`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({
-        hook_event_name: 'PreToolUse',
-        tool_name: 'Read',
-        tool_input: { file_path: '/src/foo.ts' },
-        session_id: 'test-session'
-      })
-    })
-    expect(res.status).toBe(200)
-  })
-
-  it('normalizes missing session_id to fallback', async () => {
-    const res = await fetch(`http://localhost:${port}/hook`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ hook_event_name: 'Stop' })
-    })
-    expect(res.status).toBe(200)
-    // buffer should have an event with a non-empty session_id
-    const events = await fetch(`http://localhost:${port}/buffer`).then(r => r.json())
-    expect(events[events.length - 1].session_id).toBeTruthy()
-  })
-
-  it('returns 400 on invalid JSON', async () => {
-    const res = await fetch(`http://localhost:${port}/hook`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: 'not json'
-    })
-    expect(res.status).toBe(400)
-  })
-})