agentgui 1.0.930 → 1.0.932

package/lib/ws-handlers-queue.js

@@ -1,56 +0,0 @@
-import * as execMachine from './execution-machine.js';
-
-function fail(code, message) { const e = new Error(message); e.code = code; throw e; }
-function notFound(msg = 'Not found') { fail(404, msg); }
-
-export function register(router, deps) {
-  const { queries, messageQueues, broadcastSync } = deps;
-
-  const queueSeqByConv = new Map();
-  function getNextQueueSeq(conversationId) {
-    const current = queueSeqByConv.get(conversationId) || 0;
-    const next = current + 1;
-    queueSeqByConv.set(conversationId, next);
-    return next;
-  }
-
-  router.handle('q.ls', (p) => {
-    if (!queries.getConversation(p.id)) notFound('Conversation not found');
-    const machineQueue = execMachine.getQueue(p.id);
-    return { queue: machineQueue.length > 0 ? machineQueue : (messageQueues.get(p.id) || []) };
-  });
-
-  router.handle('q.del', (p) => {
-    const machineQueue = execMachine.getQueue(p.id);
-    const mapQueue = messageQueues.get(p.id);
-    if (!machineQueue.length && !mapQueue) notFound('Queue not found');
-    const idx = machineQueue.findIndex(q => q.messageId === p.messageId);
-    if (idx === -1 && (!mapQueue || mapQueue.findIndex(q => q.messageId === p.messageId) === -1)) notFound('Queued message not found');
-    if (idx !== -1) {
-      const newQueue = [...machineQueue];
-      newQueue.splice(idx, 1);
-      execMachine.send(p.id, { type: 'SET_QUEUE', queue: newQueue });
-    }
-    if (mapQueue) {
-      const mi = mapQueue.findIndex(q => q.messageId === p.messageId);
-      if (mi !== -1) mapQueue.splice(mi, 1);
-      if (mapQueue.length === 0) messageQueues.delete(p.id);
-    }
-    const seq = getNextQueueSeq(p.id);
-    broadcastSync({ type: 'queue_status', conversationId: p.id, queueLength: execMachine.getQueue(p.id).length, seq, timestamp: Date.now() });
-    return { deleted: true };
-  });
-
-  router.handle('q.upd', (p) => {
-    const machineQueue = execMachine.getQueue(p.id);
-    const mapQueue = messageQueues.get(p.id);
-    if (!machineQueue.length && !mapQueue) notFound('Queue not found');
-    const item = machineQueue.find(q => q.messageId === p.messageId) || mapQueue?.find(q => q.messageId === p.messageId);
-    if (!item) notFound('Queued message not found');
-    if (p.content !== undefined) item.content = p.content;
-    if (p.agentId !== undefined) item.agentId = p.agentId;
-    const seq = getNextQueueSeq(p.id);
-    broadcastSync({ type: 'queue_updated', conversationId: p.id, messageId: p.messageId, content: item.content, agentId: item.agentId, seq, timestamp: Date.now() });
-    return { updated: true, item };
-  });
-}

package/lib/ws-handlers-run.js

@@ -1,182 +0,0 @@
-function err(code, message) { const e = new Error(message); e.code = code; throw e; }
-function need(p, key) { if (!p[key]) err(400, `Missing required param: ${key}`); return p[key]; }
-
-function register(router, deps) {
-  const { queries, discoveredAgents, activeExecutions, activeProcessesByRunId, broadcastSync, processMessageWithStreaming, cleanupExecution } = deps;
-
-  function findAgent(id) { const a = discoveredAgents.find(x => x.id === id); if (!a) err(404, 'Agent not found'); return a; }
-  function getRunOrThrow(id) { const r = queries.getRun(id); if (!r) err(404, 'Run not found'); return r; }
-  function getThreadOrThrow(id) { const t = queries.getThread(id); if (!t) err(404, 'Thread not found'); return t; }
-
-  function killExecution(threadId, runId) {
-    const ex = activeExecutions.get(threadId);
-    if (ex?.pid) {
-      try { process.kill(-ex.pid, 'SIGTERM'); } catch { try { process.kill(ex.pid, 'SIGTERM'); } catch {} }
-      setTimeout(() => { try { process.kill(-ex.pid, 'SIGKILL'); } catch { try { process.kill(ex.pid, 'SIGKILL'); } catch {} } }, 3000);
-    }
-    if (ex?.sessionId) queries.updateSession(ex.sessionId, { status: 'error', error: 'Cancelled by user', completed_at: Date.now() });
-    cleanupExecution(threadId);
-    activeProcessesByRunId.delete(runId);
-    return ex;
-  }
-
-  function startExecution(runId, threadId, agentId, input, config) {
-    const conv = queries.getConversation(threadId);
-    if (!conv || !input?.content) return;
-    const session = queries.createSession(threadId);
-    queries.updateRunStatus(runId, 'active');
-    activeExecutions.set(threadId, { pid: null, startTime: Date.now(), sessionId: session.id, lastActivity: Date.now() });
-    activeProcessesByRunId.set(runId, { threadId, sessionId: session.id });
-    queries.setIsStreaming(threadId, true);
-    processMessageWithStreaming(threadId, null, session.id, input.content, agentId, config?.model || null)
-      .then(() => { queries.updateRunStatus(runId, 'success'); activeProcessesByRunId.delete(runId); })
-      .catch(() => { queries.updateRunStatus(runId, 'error'); activeProcessesByRunId.delete(runId); });
-  }
-
-  router.handle('run.new', async (p) => {
-    findAgent(need(p, 'agent_id'));
-    return queries.createRun(p.agent_id, p.thread_id || null, p.input || null, p.config || null, p.webhook_url || null);
-  });
-
-  router.handle('run.get', async (p) => getRunOrThrow(need(p, 'id')));
-
-  router.handle('run.del', async (p) => {
-    try { queries.deleteRun(need(p, 'id')); } catch { err(404, 'Run not found'); }
-    return { deleted: true };
-  });
-
-  router.handle('run.resume', async (p) => {
-    const id = need(p, 'id'), run = getRunOrThrow(id);
-    if (run.status !== 'pending') err(409, 'Run is not resumable');
-    if (run.thread_id) startExecution(id, run.thread_id, run.agent_id, p.input, p.config);
-    return queries.getRun(id) || run;
-  });
-
-  router.handle('run.cancel', async (p) => {
-    const id = need(p, 'id'), run = getRunOrThrow(id);
-    if (['success', 'error', 'cancelled'].includes(run.status)) err(409, 'Run already completed or cancelled');
-    const cancelled = queries.cancelRun(id);
-    if (run.thread_id) {
-      const ex = killExecution(run.thread_id, id);
-      broadcastSync({ type: 'streaming_cancelled', sessionId: ex?.sessionId || id, conversationId: run.thread_id, runId: id, timestamp: Date.now() });
-    }
-    return cancelled;
-  });
-
-  router.handle('run.search', async (p) => queries.searchRuns(p));
-
-  router.handle('run.wait', async (p) => {
-    const id = need(p, 'id');
-    getRunOrThrow(id);
-    const timeout = p.timeout || 30000, start = Date.now();
-    return new Promise((resolve) => {
-      const poll = setInterval(() => {
-        const cur = queries.getRun(id);
-        if (cur && ['success', 'error', 'cancelled'].includes(cur.status)) { clearInterval(poll); resolve(cur); }
-        else if (Date.now() - start > timeout) { clearInterval(poll); resolve({ error: 'Run still pending', run_id: id, status: cur?.status }); }
-      }, 500);
-    });
-  });
-
-  router.handle('run.stream', async (p) => {
-    const agent_id = need(p, 'agent_id');
-    findAgent(agent_id);
-    const run = queries.createRun(agent_id, null, p.input, p.config);
-    const threadId = queries.getRun(run.run_id)?.thread_id;
-    if (threadId) startExecution(run.run_id, threadId, agent_id, p.input, p.config);
-    return run;
-  });
-
-  router.handle('run.stream.get', async (p) => getRunOrThrow(need(p, 'id')));
-
-  router.handle('thread.new', async (p) => queries.createThread(p.metadata || {}));
-  router.handle('thread.search', async (p) => queries.searchThreads(p));
-  router.handle('thread.get', async (p) => getThreadOrThrow(need(p, 'id')));
-
-  router.handle('thread.upd', async (p) => {
-    try { return queries.patchThread(need(p, 'id'), p); } catch (e) {
-      if (e.message.includes('not found')) err(404, e.message);
-      throw e;
-    }
-  });
-
-  router.handle('thread.del', async (p) => {
-    try { queries.deleteThread(need(p, 'id')); return { deleted: true }; } catch (e) {
-      if (e.message.includes('not found')) err(404, e.message);
-      if (e.message.includes('pending runs')) err(409, e.message);
-      throw e;
-    }
-  });
-
-  router.handle('thread.history', async (p) => {
-    const id = need(p, 'id'), limit = p.limit || 50, offset = p.before ? parseInt(p.before, 10) : 0;
-    const result = queries.getThreadHistory(id, limit, offset);
-    return { states: result.states, next_cursor: result.hasMore ? String(offset + limit) : null };
-  });
-
-  router.handle('thread.copy', async (p) => {
-    try {
-      const nt = queries.copyThread(need(p, 'id'));
-      return p.metadata ? queries.patchThread(nt.thread_id, { metadata: p.metadata }) : nt;
-    } catch (e) {
-      if (e.message.includes('not found')) err(404, e.message);
-      throw e;
-    }
-  });
-
-  router.handle('thread.run.stream', async (p) => {
-    const threadId = need(p, 'id'), agent_id = need(p, 'agent_id');
-    const thread = getThreadOrThrow(threadId);
-    if (thread.status !== 'idle') err(409, 'Thread has pending runs');
-    findAgent(agent_id);
-    const run = queries.createRun(agent_id, threadId, p.input, p.config);
-    startExecution(run.run_id, threadId, agent_id, p.input, p.config);
-    return run;
-  });
-
-  router.handle('thread.run.cancel', async (p) => {
-    const threadId = need(p, 'id'), runId = need(p, 'runId'), run = getRunOrThrow(runId);
-    if (run.thread_id !== threadId) err(400, 'Run does not belong to specified thread');
-    if (['success', 'error', 'cancelled'].includes(run.status)) err(409, 'Run already completed or cancelled');
-    const cancelled = queries.cancelRun(runId);
-    const ex = killExecution(threadId, runId);
-    broadcastSync({ type: 'run_cancelled', runId, threadId, sessionId: ex?.sessionId, timestamp: Date.now() });
-    return cancelled;
-  });
-
-  router.handle('thread.run.stream.get', async (p) => {
-    const threadId = need(p, 'id'), runId = need(p, 'runId');
-    getThreadOrThrow(threadId);
-    const run = queries.getRun(runId);
-    if (!run || run.thread_id !== threadId) err(404, 'Run not found on thread');
-    return run;
-  });
-
-  router.handle('thread.run.steer', async (p) => {
-    const threadId = need(p, 'id'), runId = need(p, 'runId'), instruction = need(p, 'instruction');
-    const thread = getThreadOrThrow(threadId);
-    const run = getRunOrThrow(runId);
-    if (run.thread_id !== threadId) err(400, 'Run does not belong to specified thread');
-    if (!['active', 'pending'].includes(run.status)) err(409, 'Run is not active or pending');
-
-    // Cancel current run
-    const cancelled = queries.cancelRun(runId);
-    const ex = killExecution(threadId, runId);
-    broadcastSync({ type: 'run_cancelled', runId, threadId, sessionId: ex?.sessionId, timestamp: Date.now() });
-
-    // Create new run with steering instruction injected
-    // The instruction will be processed as a follow-up in the same thread context
-    const newRun = queries.createRun(run.agent_id, threadId, { content: instruction }, run.config);
-    startExecution(newRun.run_id, threadId, run.agent_id, { content: instruction }, run.config);
-
-    return {
-      steered: true,
-      cancelled_run: cancelled,
-      new_run: newRun,
-      instruction: instruction,
-      message: 'Run interrupted and restarted with steering instruction'
-    };
-  });
-}
-
-export { register };

package/lib/ws-handlers-scripts.js

@@ -1,66 +0,0 @@
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { spawn } from 'child_process';
-import * as scriptMachine from './script-machine.js';
-
-function err(code, message) { const e = new Error(message); e.code = code; throw e; }
-
-export function register(router, deps) {
-  const { queries, broadcastSync, STARTUP_CWD, activeScripts } = deps;
-
-  router.handle('conv.scripts', (p) => {
-    const conv = queries.getConversation(p.id);
-    if (!conv) err(404, 'Not found');
-    const wd = conv.workingDirectory || STARTUP_CWD;
-    let hasStart = false, hasDev = false;
-    try {
-      const pkg = JSON.parse(fs.readFileSync(path.join(wd, 'package.json'), 'utf-8'));
-      const scripts = pkg.scripts || {};
-      hasStart = !!scripts.start;
-      hasDev = !!scripts.dev;
-    } catch {}
-    const running = scriptMachine.isRunning(p.id);
-    const ctx = scriptMachine.getContext(p.id);
-    const runningScript = running ? ctx?.script : null;
-    return { hasStart, hasDev, running, runningScript };
-  });
-
-  router.handle('conv.run-script', (p) => {
-    const conv = queries.getConversation(p.id);
-    if (!conv) err(404, 'Not found');
-    if (scriptMachine.isRunning(p.id)) err(409, 'Script already running');
-    const script = p.script;
-    if (script !== 'start' && script !== 'dev') err(400, 'Invalid script');
-    const wd = conv.workingDirectory || STARTUP_CWD;
-    try {
-      const pkg = JSON.parse(fs.readFileSync(path.join(wd, 'package.json'), 'utf-8'));
-      if (!pkg.scripts || !pkg.scripts[script]) err(400, `Script "${script}" not found`);
-    } catch (e) { if (e.code) throw e; err(400, 'No package.json'); }
-    const childEnv = { ...process.env, FORCE_COLOR: '1' };
-    delete childEnv.PORT; delete childEnv.BASE_URL; delete childEnv.HOT_RELOAD;
-    const isWindows = os.platform() === 'win32';
-    const child = spawn('npm', ['run', script], { cwd: wd, stdio: ['ignore', 'pipe', 'pipe'], detached: true, env: childEnv, shell: isWindows });
-    scriptMachine.send(p.id, { type: 'START', process: child, script, pid: child.pid });
-    activeScripts.set(p.id, { process: child, script, startTime: Date.now() });
-    broadcastSync({ type: 'script_started', conversationId: p.id, script, timestamp: Date.now() });
-    const onData = (stream) => (chunk) => broadcastSync({ type: 'script_output', conversationId: p.id, data: chunk.toString(), stream, timestamp: Date.now() });
-    child.stdout.on('data', onData('stdout'));
-    child.stderr.on('data', onData('stderr'));
-    child.on('error', (e) => { scriptMachine.send(p.id, { type: 'ERROR' }); activeScripts.delete(p.id); broadcastSync({ type: 'script_stopped', conversationId: p.id, code: 1, error: e.message, timestamp: Date.now() }); });
-    child.on('close', (code) => { scriptMachine.send(p.id, { type: 'CLOSE' }); activeScripts.delete(p.id); broadcastSync({ type: 'script_stopped', conversationId: p.id, code: code || 0, timestamp: Date.now() }); });
-    return { ok: true, script, pid: child.pid };
-  });
-
-  router.handle('conv.stop-script', (p) => {
-    if (!scriptMachine.isRunning(p.id)) err(404, 'No running script');
-    const ctx = scriptMachine.getContext(p.id);
-    const proc = ctx?.process;
-    scriptMachine.send(p.id, { type: 'STOP' });
-    if (proc) {
-      try { process.kill(-proc.pid, 'SIGTERM'); } catch { try { proc.kill('SIGTERM'); } catch {} }
-      setTimeout(() => { try { process.kill(-proc.pid, 'SIGKILL'); } catch { try { proc.kill('SIGKILL'); } catch {} } }, 5000);
-    }
-    return { ok: true };
-  });
-}

package/lib/ws-handlers-session.js

@@ -1,105 +0,0 @@
-import { queryModels } from './acp-sdk-manager.js';
-
-const STATIC_MODELS = {
-  'claude-code': [
-    { id: 'haiku', label: 'Haiku' },
-    { id: 'sonnet', label: 'Sonnet' },
-    { id: 'opus', label: 'Opus' }
-  ],
-  'gemini': [
-    { id: 'gemini-3-pro', label: 'Gemini 3 Pro' },
-    { id: 'gemini-3-flash', label: 'Gemini 3 Flash' },
-    { id: 'gemini-3.1-pro', label: 'Gemini 3.1 Pro' },
-    { id: 'gemini-2.5-pro', label: 'Gemini 2.5 Pro' },
-    { id: 'gemini-2.5-flash', label: 'Gemini 2.5 Flash' },
-    { id: 'gemini-2.0-flash', label: 'Gemini 2.0 Flash' }
-  ]
-};
-
-export function register(router, deps) {
-  const { db, discoveredAgents, modelCache, getAgentDescriptor } = deps;
-  console.log('[ws-handlers-session] register() called with discoveredAgents.length:', discoveredAgents.length);
-
-  router.handle('sess.get', (p) => {
-    const sess = db.getSession(p.id);
-    if (!sess) throw { code: 404, message: 'Not found' };
-    return { session: sess, events: db.getSessionEvents(p.id) };
-  });
-
-  router.handle('sess.latest', (p) => {
-    const s = db.getLatestSession(p.id);
-    if (!s) return { session: null };
-    return { session: s, events: db.getSessionEvents(s.id) };
-  });
-
-  router.handle('sess.chunks', (p) => {
-    if (!db.getSession(p.id)) throw { code: 404, message: 'Session not found' };
-    const sinceSeq = parseInt(p.sinceSeq ?? '-1');
-    const since = parseInt(p.since ?? '0');
-    const chunks = sinceSeq >= 0 ? db.getChunksSinceSeq(p.id, sinceSeq) : db.getChunksSince(p.id, since);
-    return { ok: true, chunks };
-  });
-
-  router.handle('sess.exec', (p) => {
-    const limit = Math.min(parseInt(p.limit || '1000'), 5000);
-    const offset = Math.max(parseInt(p.offset || '0'), 0);
-    const session = db.getSession(p.id);
-    const allChunks = session ? (db.getChunksSince(p.id, 0) || []) : [];
-    const filterType = p.filterType;
-    const filtered = filterType ? allChunks.filter(e => e.type === filterType) : allChunks;
-    return {
-      sessionId: p.id,
-      events: filtered.slice(offset, offset + limit),
-      total: filtered.length,
-      limit,
-      offset,
-      hasMore: offset + limit < filtered.length,
-      metadata: {
-        status: session?.status || 'unknown',
-        startTime: session?.created_at || null,
-        duration: session?.completed_at && session?.created_at ? session.completed_at - session.created_at : 0,
-        eventCount: filtered.length
-      }
-    };
-  });
-
-  router.handle('agent.ls', () => {
-    console.log('[agent.ls] discoveredAgents.length:', discoveredAgents.length);
-    console.log('[agent.ls] agent IDs:', discoveredAgents.map(a => a.id).join(', '));
-    return {
-      agents: discoveredAgents.map(a => ({
-        id: a.id, name: a.name, icon: a.icon, path: a.path,
-        protocol: a.protocol || 'unknown', description: a.description || '', status: 'available'
-      }))
-    };
-  });
-
-  router.handle('agent.get', (p) => {
-    const a = discoveredAgents.find(x => x.id === p.id);
-    if (!a) throw { code: 404, message: 'Agent not found' };
-    return { id: a.id, name: a.name, description: a.description || '', icon: a.icon || null, status: 'available' };
-  });
-
-  router.handle('agent.desc', (p) => {
-    const d = getAgentDescriptor(p.id);
-    if (!d) throw { code: 404, message: 'Agent not found' };
-    return d;
-  });
-
-  router.handle('agent.models', async (p) => {
-    const cached = modelCache.get(p.id);
-    if (cached && (Date.now() - cached.ts) < 300000) return { models: cached.models };
-    let models = [];
-    const agent = discoveredAgents.find(x => x.id === p.id);
-    const targetId = agent?.protocol === 'cli-wrapper' && agent.acpId ? agent.acpId : p.id;
-    if (p.id === 'cli-claude' || STATIC_MODELS[targetId]) {
-      models = STATIC_MODELS[targetId] || STATIC_MODELS['claude-code'];
-    } else if (agent?.protocol === 'acp' || (agent?.protocol === 'cli-wrapper' && agent.acpId)) {
-      models = await queryModels(targetId);
-    }
-    if (models.length > 0) modelCache.set(p.id, { models, ts: Date.now() });
-    return { models };
-  });
-
-  router.handle('agent.search', (p) => db.searchAgents(discoveredAgents, p.query || p));
-}

package/lib/ws-handlers-session2.js

@@ -1,85 +0,0 @@
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { execSync, spawn } from 'child_process';
-
-function spawnScript(cmd, args, convId, scriptName, agentId, deps) {
-  const { activeScripts, broadcastSync, modelCache } = deps;
-  if (activeScripts.has(convId)) throw { code: 409, message: 'Process already running' };
-  const child = spawn(cmd, args, {
-    stdio: ['pipe', 'pipe', 'pipe'],
-    env: { ...process.env, FORCE_COLOR: '1' },
-    shell: os.platform() === 'win32'
-  });
-  activeScripts.set(convId, { process: child, script: scriptName, startTime: Date.now() });
-  broadcastSync({ type: 'script_started', conversationId: convId, script: scriptName, agentId, timestamp: Date.now() });
-  const relay = (stream) => (chunk) => {
-    broadcastSync({ type: 'script_output', conversationId: convId, data: chunk.toString(), stream, timestamp: Date.now() });
-  };
-  child.stdout.on('data', relay('stdout'));
-  child.stderr.on('data', relay('stderr'));
-  child.on('error', (err) => {
-    activeScripts.delete(convId);
-    broadcastSync({ type: 'script_stopped', conversationId: convId, code: 1, error: err.message, timestamp: Date.now() });
-  });
-  child.on('close', (code) => {
-    activeScripts.delete(convId);
-    if (modelCache && agentId) modelCache.delete(agentId);
-    broadcastSync({ type: 'script_stopped', conversationId: convId, code: code || 0, timestamp: Date.now() });
-  });
-  return child.pid;
-}
-
-function readJson(filePath) {
-  try { return fs.existsSync(filePath) ? JSON.parse(fs.readFileSync(filePath, 'utf-8')) : null; } catch { return null; }
-}
-
-function checkAgentAuth(agent) {
-  const s = { id: agent.id, name: agent.name, authenticated: false, detail: '' };
-  try {
-    if (agent.id === 'claude-code') {
-      const creds = readJson(path.join(os.homedir(), '.claude', '.credentials.json'));
-      if (creds?.claudeAiOauth?.expiresAt > Date.now()) {
-        s.authenticated = true;
-        s.detail = creds.claudeAiOauth.subscriptionType || 'authenticated';
-      } else { s.detail = creds ? 'expired' : 'no credentials'; }
-    } else if (agent.id === 'gemini') {
-      const oauth = readJson(path.join(os.homedir(), '.gemini', 'oauth_creds.json'));
-      const accts = readJson(path.join(os.homedir(), '.gemini', 'google_accounts.json'));
-      const hasOAuth = !!(oauth?.refresh_token || oauth?.access_token);
-      if (accts?.active) { s.authenticated = true; s.detail = accts.active; }
-      else if (hasOAuth) { s.authenticated = true; s.detail = 'oauth'; }
-      else { s.detail = accts ? 'logged out' : 'no credentials'; }
-    } else if (agent.id === 'opencode') {
-      const out = execSync('opencode auth list 2>&1', { encoding: 'utf-8', timeout: 5000 });
-      const m = out.match(/(\d+)\s+credentials?/);
-      if (m && parseInt(m[1], 10) > 0) { s.authenticated = true; s.detail = m[1] + ' credential(s)'; }
-      else { s.detail = 'no credentials'; }
-    } else { s.detail = 'unknown'; }
-  } catch { s.detail = 'check failed'; }
-  return s;
-}
-
-export function register(router, deps) {
-  const { discoveredAgents, modelCache, activeScripts, broadcastSync } = deps;
-
-  router.handle('agent.auth', async (p) => {
-    const agentId = p.id;
-    if (!discoveredAgents.find(a => a.id === agentId)) throw { code: 404, message: 'Agent not found' };
-    const cmds = { 'claude-code': { cmd: 'claude', args: ['setup-token'] }, 'opencode': { cmd: 'opencode', args: ['auth', 'login'] } };
-    const c = cmds[agentId];
-    if (!c) throw { code: 400, message: 'No auth command for this agent (OAuth flows removed; configure provider key via /api/auth/save-config)' };
-    const pid = spawnScript(c.cmd, c.args, '__agent_auth__', 'auth-' + agentId, agentId, { activeScripts, broadcastSync });
-    return { ok: true, agentId, pid };
-  });
-
-  router.handle('agent.authstat', () => ({ agents: discoveredAgents.map(checkAgentAuth) }));
-
-  router.handle('agent.update', (p) => {
-    const cmds = { 'claude-code': { cmd: 'claude', args: ['update', '--yes'] } };
-    const c = cmds[p.id];
-    if (!c) throw { code: 400, message: 'No update command for this agent' };
-    const pid = spawnScript(c.cmd, c.args, '__agent_update__', 'update-' + p.id, p.id, { activeScripts, broadcastSync, modelCache });
-    return { ok: true, agentId: p.id, pid };
-  });
-}

package/lib/ws-legacy-handlers.js

@@ -1,51 +0,0 @@
-export function registerLegacyHandler(wsRouter, { subscriptionIndex, execMachine, activeExecutions, messageQueues, queries, getSeq, sendWs, debugLog }) {
-  wsRouter.onLegacy((data, ws) => {
-    try {
-      if (data.type === 'subscribe') {
-        if (data.sessionId) {
-          ws.subscriptions.add(data.sessionId);
-          if (!subscriptionIndex.has(data.sessionId)) subscriptionIndex.set(data.sessionId, new Set());
-          subscriptionIndex.get(data.sessionId).add(ws);
-        }
-        if (data.conversationId) {
-          const key = `conv-${data.conversationId}`;
-          ws.subscriptions.add(key);
-          if (!subscriptionIndex.has(key)) subscriptionIndex.set(key, new Set());
-          subscriptionIndex.get(key).add(ws);
-        }
-        const subTarget = data.sessionId || data.conversationId;
-        debugLog(`[WebSocket] Client ${ws.clientId} subscribed to ${subTarget}`);
-        sendWs(ws, { type: 'subscription_confirmed', sessionId: data.sessionId, conversationId: data.conversationId, timestamp: Date.now() });
-        if (data.conversationId && execMachine.isActive(data.conversationId)) {
-          const ctx = execMachine.getContext(data.conversationId);
-          const execution = activeExecutions.get(data.conversationId);
-          const sessionId = ctx?.sessionId || execution?.sessionId;
-          const conv = queries.getConversation(data.conversationId);
-          const queueLength = execMachine.getQueue(data.conversationId).length || messageQueues.get(data.conversationId)?.length || 0;
-          sendWs(ws, { type: 'streaming_start', sessionId, conversationId: data.conversationId, agentId: conv?.agentType || conv?.agentId || 'claude-code', queueLength, resumed: true, seq: getSeq(), timestamp: Date.now() });
-        }
-      } else if (data.type === 'unsubscribe') {
-        if (data.sessionId) {
-          ws.subscriptions.delete(data.sessionId);
-          const idx = subscriptionIndex.get(data.sessionId);
-          if (idx) { idx.delete(ws); if (idx.size === 0) subscriptionIndex.delete(data.sessionId); }
-        }
-        if (data.conversationId) {
-          const key = `conv-${data.conversationId}`;
-          ws.subscriptions.delete(key);
-          const idx = subscriptionIndex.get(key);
-          if (idx) { idx.delete(ws); if (idx.size === 0) subscriptionIndex.delete(key); }
-        }
-        debugLog(`[WebSocket] Client ${ws.clientId} unsubscribed from ${data.sessionId || data.conversationId}`);
-      } else if (data.type === 'get_subscriptions') {
-        sendWs(ws, { type: 'subscriptions', subscriptions: Array.from(ws.subscriptions), timestamp: Date.now() });
-      } else if (data.type === 'latency_report') {
-        ws.latencyTier = data.quality || 'good';
-        ws.latencyAvg = data.avg || 0;
-        ws.latencyTrend = data.trend || 'stable';
-      } else if (data.type === 'ping') {
-        sendWs(ws, { type: 'pong', requestId: data.requestId, timestamp: Date.now() });
-      }
-    } catch (err) { console.error('[WS-LEGACY] Handler error (contained):', err.message); }
-  });
-}