agentgui 1.0.715 → 1.0.716

package/lib/tool-provisioner.js

@@ -0,0 +1,93 @@
+import { checkToolViaBunx } from './tool-version.js';
+
+let updateCheckInterval = null;
+const UPDATE_CHECK_INTERVAL = 6 * 60 * 60 * 1000;
+
+export async function autoProvision(TOOLS, statusCache, install, broadcast) {
+  const log = (msg) => console.log('[TOOLS-AUTO] ' + msg);
+  log('Starting background tool provisioning...');
+  for (const tool of TOOLS) {
+    try {
+      const status = await checkToolViaBunx(tool.pkg, tool.pluginId, tool.category, tool.frameWork, true, TOOLS);
+      statusCache.set(tool.id, { ...status, toolId: tool.id, timestamp: Date.now() });
+      if (!status.installed) {
+        log(`${tool.id} not installed, installing...`);
+        broadcast({ type: 'tool_install_started', toolId: tool.id });
+        const result = await install(tool.id, (msg) => {
+          broadcast({ type: 'tool_install_progress', toolId: tool.id, data: msg });
+        });
+        if (result.success) {
+          log(`${tool.id} installed v${result.version}`);
+          broadcast({ type: 'tool_install_complete', toolId: tool.id, data: result });
+        } else {
+          log(`${tool.id} install failed: ${result.error}`);
+          broadcast({ type: 'tool_install_failed', toolId: tool.id, data: result });
+        }
+      } else if (status.upgradeNeeded) {
+        log(`${tool.id} needs update (${status.installedVersion} -> ${status.publishedVersion})`);
+        broadcast({ type: 'tool_install_started', toolId: tool.id });
+        const { update } = await import('./tool-spawner.js').then(m => m);
+        const result = await install(tool.id, (msg) => {
+          broadcast({ type: 'tool_update_progress', toolId: tool.id, data: msg });
+        });
+        if (result.success) {
+          log(`${tool.id} updated to v${result.version}`);
+          broadcast({ type: 'tool_update_complete', toolId: tool.id, data: result });
+        } else {
+          log(`${tool.id} update failed: ${result.error}`);
+          broadcast({ type: 'tool_update_failed', toolId: tool.id, data: result });
+        }
+      } else {
+        log(`${tool.id} v${status.installedVersion} up-to-date`);
+        broadcast({ type: 'tool_status_update', toolId: tool.id, data: { installed: true, isUpToDate: true, installedVersion: status.installedVersion, status: 'installed' } });
+      }
+    } catch (err) {
+      log(`${tool.id} error: ${err.message}`);
+    }
+  }
+  log('Provisioning complete');
+}
+
+export function startPeriodicUpdateCheck(TOOLS, statusCache, update, broadcast) {
+  const log = (msg) => console.log('[TOOLS-PERIODIC] ' + msg);
+  if (updateCheckInterval) { log('Update check already running'); return; }
+  log('Starting periodic tool update checker (every 6 hours)');
+
+  const check = async () => {
+    log('Checking for tool updates...');
+    for (const tool of TOOLS) {
+      try {
+        const status = await checkToolViaBunx(tool.pkg, tool.pluginId, tool.category, tool.frameWork, false, TOOLS);
+        if (status.upgradeNeeded) {
+          log(`Update available for ${tool.id}: ${status.installedVersion} -> ${status.publishedVersion}`);
+          broadcast({ type: 'tool_update_available', toolId: tool.id, data: { installedVersion: status.installedVersion, publishedVersion: status.publishedVersion } });
+          log(`Auto-updating ${tool.id}...`);
+          const result = await update(tool.id, (msg) => {
+            broadcast({ type: 'tool_update_progress', toolId: tool.id, data: msg });
+          });
+          if (result.success) {
+            log(`${tool.id} auto-updated to v${result.version}`);
+            broadcast({ type: 'tool_update_complete', toolId: tool.id, data: { ...result, autoUpdated: true } });
+          } else {
+            log(`${tool.id} auto-update failed: ${result.error}`);
+            broadcast({ type: 'tool_update_failed', toolId: tool.id, data: { ...result, autoUpdated: true } });
+          }
+        }
+      } catch (err) {
+        log(`Error checking ${tool.id}: ${err.message}`);
+      }
+    }
+    log('Update check complete');
+  };
+
+  setImmediate(() => check().catch(err => log(`Initial check failed: ${err.message}`)));
+  updateCheckInterval = setInterval(() => check().catch(err => log(`Periodic check failed: ${err.message}`)), UPDATE_CHECK_INTERVAL);
+}
+
+export function stopPeriodicUpdateCheck() {
+  if (updateCheckInterval) {
+    clearInterval(updateCheckInterval);
+    updateCheckInterval = null;
+    console.log('[TOOLS-PERIODIC] Update check stopped');
+  }
+}

package/lib/tool-spawner.js

@@ -0,0 +1,121 @@
+import { spawn } from 'child_process';
+import os from 'os';
+import { getCliVersion, getInstalledVersion, clearVersionCache, checkToolViaBunx } from './tool-version.js';
+
+const isWindows = os.platform() === 'win32';
+
+const spawnNpmInstall = (pkg, onProgress) => new Promise((resolve) => {
+  const cmd = isWindows ? 'npm.cmd' : 'npm';
+  let completed = false, stderr = '', stdout = '';
+  let proc;
+  try {
+    proc = spawn(cmd, ['install', '-g', pkg], { stdio: ['pipe', 'pipe', 'pipe'], timeout: 300000, shell: isWindows, windowsHide: true });
+  } catch (err) {
+    return resolve({ success: false, error: `Failed to spawn npm install: ${err.message}` });
+  }
+  if (!proc) return resolve({ success: false, error: 'Failed to spawn npm process' });
+  const timer = setTimeout(() => { if (!completed) { completed = true; try { proc.kill('SIGKILL'); } catch (_) {} resolve({ success: false, error: 'Timeout (5min)' }); } }, 300000);
+  const onData = (d) => { if (onProgress) onProgress({ type: 'progress', data: d.toString() }); };
+  if (proc.stdout) proc.stdout.on('data', (d) => { stdout += d.toString(); onData(d); });
+  if (proc.stderr) proc.stderr.on('data', (d) => { stderr += d.toString(); onData(d); });
+  proc.on('close', (code) => {
+    clearTimeout(timer);
+    if (completed) return;
+    completed = true;
+    resolve(code === 0 ? { success: true, error: null, pkg } : { success: false, error: (stdout + stderr).substring(0, 1000) || 'Failed' });
+  });
+  proc.on('error', (err) => { clearTimeout(timer); if (!completed) { completed = true; resolve({ success: false, error: err.message }); } });
+});
+
+const spawnBunxProc = (pkg, onProgress) => new Promise((resolve) => {
+  const cmd = isWindows ? 'bun.cmd' : 'bun';
+  let completed = false, stderr = '', stdout = '';
+  let lastDataTime = Date.now();
+  let proc;
+  try {
+    proc = spawn(cmd, ['x', pkg], { stdio: ['pipe', 'pipe', 'pipe'], timeout: 300000, shell: isWindows, windowsHide: true });
+  } catch (err) {
+    return resolve({ success: false, error: `Failed to spawn bun x: ${err.message}` });
+  }
+  if (!proc) return resolve({ success: false, error: 'Failed to spawn bun x process' });
+
+  const timer = setTimeout(() => {
+    if (!completed) { completed = true; try { proc.kill('SIGKILL'); } catch (_) {} resolve({ success: false, error: 'Timeout (5min)' }); }
+  }, 300000);
+
+  const heartbeatTimer = setInterval(() => {
+    if (completed) { clearInterval(heartbeatTimer); return; }
+    const elapsed = Date.now() - lastDataTime;
+    if (elapsed > 30000) console.warn(`[tool-manager] No output from bun x ${pkg} for ${elapsed}ms - process may be hung`);
+  }, 30000);
+
+  const onData = (d) => { lastDataTime = Date.now(); if (onProgress) onProgress({ type: 'progress', data: d.toString() }); };
+  if (proc.stdout) proc.stdout.on('data', (d) => { stdout += d.toString(); onData(d); });
+  if (proc.stderr) proc.stderr.on('data', (d) => { stderr += d.toString(); onData(d); });
+
+  proc.on('close', (code) => {
+    clearTimeout(timer);
+    clearInterval(heartbeatTimer);
+    if (completed) return;
+    completed = true;
+    const output = stdout + stderr;
+    const ok = [code === 0, output.includes('upgraded'), output.includes('registered'),
+      output.includes('Hooks registered'), output.includes('successfully'),
+      output.includes('Done'), code === 0 && !output.includes('error')].some(Boolean);
+    resolve(ok ? { success: true, error: null, pkg } : { success: false, error: output.substring(0, 1000) || 'Failed' });
+  });
+
+  proc.on('error', (err) => {
+    clearTimeout(timer);
+    clearInterval(heartbeatTimer);
+    if (!completed) { completed = true; resolve({ success: false, error: `Process error: ${err.message}` }); }
+  });
+});
+
+function spawnForTool(tool, onProgress) {
+  const pkg = tool.installPkg || tool.pkg;
+  return tool.category === 'cli' ? spawnNpmInstall(pkg, onProgress) : spawnBunxProc(pkg, onProgress);
+}
+
+async function postInstallRefresh(tool, statusCache, checkToolStatusAsync) {
+  await new Promise(r => setTimeout(r, 500));
+  statusCache.delete(tool.id);
+  clearVersionCache();
+  const version = tool.category === 'cli' ? getCliVersion(tool.pkg) : getInstalledVersion(tool.pkg, tool.pluginId, tool.frameWork);
+  const freshStatus = await checkToolStatusAsync(tool.id);
+  return { success: true, error: null, version: version || freshStatus.publishedVersion || 'unknown', ...freshStatus };
+}
+
+export function createInstaller(getTool, installLocks, statusCache, checkToolStatusAsync) {
+  async function install(toolId, onProgress) {
+    const tool = getTool(toolId);
+    if (!tool) return { success: false, error: 'Tool not found' };
+    if (installLocks.get(toolId)) return { success: false, error: 'Install in progress' };
+    installLocks.set(toolId, true);
+    try {
+      const result = await spawnForTool(tool, onProgress);
+      if (result.success) return await postInstallRefresh(tool, statusCache, checkToolStatusAsync);
+      return result;
+    } finally {
+      installLocks.delete(toolId);
+    }
+  }
+
+  async function update(toolId, onProgress) {
+    const tool = getTool(toolId);
+    if (!tool) return { success: false, error: 'Tool not found' };
+    const current = await checkToolStatusAsync(toolId);
+    if (!current?.installed) return { success: false, error: 'Tool not installed' };
+    if (installLocks.get(toolId)) return { success: false, error: 'Install in progress' };
+    installLocks.set(toolId, true);
+    try {
+      const result = await spawnForTool(tool, onProgress);
+      if (result.success) return await postInstallRefresh(tool, statusCache, checkToolStatusAsync);
+      return result;
+    } finally {
+      installLocks.delete(toolId);
+    }
+  }
+
+  return { install, update };
+}

package/lib/tool-version.js

@@ -0,0 +1,196 @@
+import os from 'os';
+import fs from 'fs';
+import path from 'path';
+import { execSync } from 'child_process';
+
+const isWindows = os.platform() === 'win32';
+const homeDir = os.homedir();
+
+const BIN_MAP = {
+  '@anthropic-ai/claude-code': 'claude',
+  'opencode-ai': 'opencode',
+  '@google/gemini-cli': 'gemini',
+  '@kilocode/cli': 'kilo',
+  '@openai/codex': 'codex',
+  'agent-browser': 'agent-browser',
+};
+
+const FRAMEWORK_PATHS = {
+  claude: {
+    pluginDir: (pluginId) => path.join(homeDir, '.claude', 'plugins', pluginId),
+    versionFile: (pluginId) => path.join(homeDir, '.claude', 'plugins', pluginId, 'plugin.json'),
+    parseVersion: (filePath) => JSON.parse(fs.readFileSync(filePath, 'utf-8')).version,
+  },
+  opencode: {
+    pluginDir: (pluginId) => path.join(homeDir, '.config', 'opencode', 'agents', pluginId),
+    markerFile: (pluginId) => path.join(homeDir, '.config', 'opencode', 'agents', pluginId + '.md'),
+    versionFile: (pluginId) => path.join(homeDir, '.config', 'opencode', 'agents', pluginId, 'plugin.json'),
+    parseVersion: (filePath) => JSON.parse(fs.readFileSync(filePath, 'utf-8')).version,
+    fallbackInstalled: true,
+  },
+  gemini: {
+    pluginDir: (pluginId) => path.join(homeDir, '.gemini', 'extensions', pluginId),
+    versionFile: (pluginId) => path.join(homeDir, '.gemini', 'extensions', pluginId, 'gemini-extension.json'),
+    parseVersion: (filePath) => JSON.parse(fs.readFileSync(filePath, 'utf-8')).version,
+  },
+  kilo: {
+    pluginDir: (pluginId) => path.join(homeDir, '.config', 'kilo', 'agents', pluginId),
+    markerFile: (pluginId) => path.join(homeDir, '.config', 'kilo', 'agents', pluginId + '.md'),
+    versionFile: (pluginId) => path.join(homeDir, '.config', 'kilo', 'agents', pluginId, 'plugin.json'),
+    parseVersion: (filePath) => JSON.parse(fs.readFileSync(filePath, 'utf-8')).version,
+    fallbackInstalled: true,
+  },
+  codex: {
+    pluginDir: (pluginId) => path.join(homeDir, '.codex', 'plugins', pluginId),
+    versionFile: (pluginId) => path.join(homeDir, '.codex', 'plugins', pluginId, 'plugin.json'),
+    parseVersion: (filePath) => JSON.parse(fs.readFileSync(filePath, 'utf-8')).version,
+    fallbackInstalled: true,
+  },
+};
+
+function tryReadVersion(fwConfig, pluginId) {
+  try {
+    const vFile = fwConfig.versionFile(pluginId);
+    if (fs.existsSync(vFile)) {
+      const ver = fwConfig.parseVersion(vFile);
+      if (ver) return ver;
+    }
+  } catch (_) {}
+  return null;
+}
+
+function tryBunCache(pkg) {
+  try {
+    const cachePath = path.join(homeDir, '.gmweb/cache/.bun/install/cache');
+    const dirs = fs.readdirSync(cachePath).filter(d => d.startsWith(pkg + '@'));
+    const latest = dirs.sort().reverse()[0];
+    if (latest) {
+      const pkgJson = JSON.parse(fs.readFileSync(path.join(cachePath, latest, 'package.json'), 'utf-8'));
+      if (pkgJson.version) return pkgJson.version;
+    }
+  } catch (_) {}
+  return null;
+}
+
+export function getInstalledVersion(pkg, pluginId = null, frameWork = null, tools = []) {
+  try {
+    const tool = tools.find(t => t.pkg === pkg);
+    const actualPluginId = pluginId || tool?.pluginId || pkg;
+    const actualFrameWork = frameWork || tool?.frameWork;
+
+    const frameworks = actualFrameWork ? [actualFrameWork] : Object.keys(FRAMEWORK_PATHS);
+    for (const fw of frameworks) {
+      const fwConfig = FRAMEWORK_PATHS[fw];
+      if (!fwConfig) continue;
+
+      const version = tryReadVersion(fwConfig, actualPluginId);
+      if (version) return version;
+
+      if (fwConfig.fallbackInstalled) {
+        const hasMarker = fwConfig.markerFile && fs.existsSync(fwConfig.markerFile(actualPluginId));
+        const hasDir = fs.existsSync(fwConfig.pluginDir(actualPluginId));
+        if (hasMarker || hasDir) {
+          const cached = tryBunCache(pkg);
+          if (cached) return cached;
+          return 'installed';
+        }
+      }
+    }
+  } catch (_) {}
+  return null;
+}
+
+export function checkCliInstalled(pkg) {
+  try {
+    const cmd = isWindows ? 'where' : 'which';
+    const bin = BIN_MAP[pkg];
+    if (bin) {
+      execSync(`${cmd} ${bin}`, { stdio: 'pipe', timeout: 3000, windowsHide: true });
+      return true;
+    }
+  } catch (_) {}
+  return false;
+}
+
+export function getCliVersion(pkg) {
+  try {
+    const bin = BIN_MAP[pkg];
+    if (!bin) return null;
+    try {
+      const versionFlag = pkg === 'agent-browser' ? '-V' : '--version';
+      const out = execSync(`${bin} ${versionFlag}`, { stdio: 'pipe', timeout: 1000, encoding: 'utf8', windowsHide: true });
+      const match = out.match(/(\d+\.\d+\.\d+)/);
+      if (match) {
+        console.log(`[tool-manager] CLI ${pkg} (${bin}) version: ${match[1]}`);
+        return match[1];
+      }
+    } catch (err) {
+      console.log(`[tool-manager] CLI ${pkg} (${bin}) version detection failed: ${err.message.split('\n')[0]}`);
+    }
+  } catch (err) {
+    console.log(`[tool-manager] Error in getCliVersion for ${pkg}:`, err.message);
+  }
+  return null;
+}
+
+export function checkToolInstalled(pluginId, frameWork = null) {
+  try {
+    const frameworks = frameWork ? [frameWork] : Object.keys(FRAMEWORK_PATHS);
+    for (const fw of frameworks) {
+      const fwConfig = FRAMEWORK_PATHS[fw];
+      if (!fwConfig) continue;
+      if (fs.existsSync(fwConfig.pluginDir(pluginId))) return true;
+      if (fwConfig.markerFile && fs.existsSync(fwConfig.markerFile(pluginId))) return true;
+    }
+  } catch (_) {}
+  return false;
+}
+
+export function compareVersions(v1, v2) {
+  if (!v1 || !v2) return false;
+  const parts1 = v1.split('.').map(Number);
+  const parts2 = v2.split('.').map(Number);
+  for (let i = 0; i < Math.max(parts1.length, parts2.length); i++) {
+    const p1 = parts1[i] || 0;
+    const p2 = parts2[i] || 0;
+    if (p1 < p2) return true;
+    if (p1 > p2) return false;
+  }
+  return false;
+}
+
+const versionCache = new Map();
+
+export function getPublishedVersion(pkg) {
+  const cacheKey = `published-${pkg}`;
+  const cached = versionCache.get(cacheKey);
+  if (cached && Date.now() - cached.timestamp < 86400000) {
+    return cached.version;
+  }
+  return null;
+}
+
+export function clearVersionCache() {
+  versionCache.clear();
+}
+
+export async function checkToolViaBunx(pkg, pluginId = null, category = 'plugin', frameWork = null, skipPublishedVersion = false, tools = []) {
+  try {
+    const isCli = category === 'cli';
+    const installed = isCli ? checkCliInstalled(pkg) : checkToolInstalled(pluginId || pkg, frameWork);
+    const installedVersion = isCli ? getCliVersion(pkg) : getInstalledVersion(pkg, pluginId, frameWork, tools);
+    let publishedVersion = null;
+    if (!skipPublishedVersion) {
+      publishedVersion = getPublishedVersion(pkg);
+    }
+    const needsUpdate = installed && publishedVersion && compareVersions(installedVersion, publishedVersion);
+    const isUpToDate = installed && !needsUpdate;
+    return { installed, isUpToDate, upgradeNeeded: needsUpdate, output: 'version-check', installedVersion, publishedVersion };
+  } catch (err) {
+    console.log(`[tool-manager] Error checking ${pkg}:`, err.message);
+    const isCli = category === 'cli';
+    const installed = isCli ? checkCliInstalled(pkg) : checkToolInstalled(pluginId || pkg, frameWork);
+    const installedVersion = isCli ? getCliVersion(pkg) : getInstalledVersion(pkg, pluginId, frameWork, tools);
+    return { installed, isUpToDate: false, upgradeNeeded: false, output: '', installedVersion, publishedVersion: null };
+  }
+}

package/lib/ws-handlers-conv.js

@@ -6,54 +6,21 @@ 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); }
 function expandTilde(p) { return p && p.startsWith('~') ? path.join(os.homedir(), p.slice(1)) : p; }
-
 function validate(schema, params) {
   const result = schema.safeParse(params);
   if (!result.success) fail(400, result.error.issues.map(i => i.message).join('; '));
   return result.data;
 }
 
-const ConvNewSchema = z.object({
-  agentId: z.string().optional(),
-  title: z.string().optional(),
-  workingDirectory: z.string().optional(),
-  model: z.string().optional(),
-  subAgent: z.string().optional(),
-}).passthrough();
-
-const ConvUpdSchema = z.object({
-  id: z.string().min(1, 'id required'),
-}).passthrough();
-
-const MsgStreamSchema = z.object({
-  id: z.string().min(1, 'conversation id required'),
-  content: z.union([z.string(), z.any()]).optional(),
-  message: z.union([z.string(), z.any()]).optional(),
-  agentId: z.string().optional(),
-  model: z.string().optional(),
-  subAgent: z.string().optional(),
-}).passthrough();
-
-const ConvSteerSchema = z.object({
-  id: z.string().min(1, 'conversation id required'),
-  content: z.union([z.string(), z.record(z.any())]).refine(v => v !== undefined && v !== null && v !== '', { message: 'content required' }),
-}).passthrough();
+const ConvNewSchema = z.object({ agentId: z.string().optional(), title: z.string().optional(), workingDirectory: z.string().optional(), model: z.string().optional(), subAgent: z.string().optional() }).passthrough();
+const ConvUpdSchema = z.object({ id: z.string().min(1, 'id required') }).passthrough();
+const ConvSteerSchema = z.object({ id: z.string().min(1, 'conversation id required'), content: z.union([z.string(), z.record(z.any())]).refine(v => v !== undefined && v !== null && v !== '', { message: 'content required' }) }).passthrough();
 
 export function register(router, deps) {
-  const { queries, activeExecutions, messageQueues, rateLimitState,
-    broadcastSync, processMessageWithStreaming, cleanupExecution, logError = () => {},
+  const { queries, activeExecutions, rateLimitState,
+    broadcastSync, processMessageWithStreaming, cleanupExecution,
     getJsonlWatcher = () => null } = deps;
 
-  // Per-conversation queue seq counter for event ordering
-  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('conv.ls', () => {
     const conversations = queries.getConversationsList();
     for (const c of conversations) { if (c.isStreaming && !execMachine.isActive(c.id)) c.isStreaming = 0; }
@@ -205,164 +172,4 @@ export function register(router, deps) {
     return { ok: true, steered: true, conversationId: p.id, messageId: message.id };
   });
 
-  router.handle('msg.ls', (p) => {
-    return queries.getPaginatedMessages(p.id, Math.min(p.limit || 50, 100), Math.max(p.offset || 0, 0));
-  });
-
-  router.handle('msg.ls.earlier', (p) => {
-    if (!p.id) fail(400, 'Missing conversation id');
-    if (!p.before) fail(400, 'Missing before messageId parameter');
-    const limit = Math.min(p.limit || 50, 100);
-    const result = queries.getMessagesBefore(p.id, p.before, limit);
-    return { ok: true, messages: result.messages, total: result.total, hasMore: result.hasMore, limit: result.limit };
-  });
-
-  function startExecution(convId, message, agentId, model, content, subAgent) {
-    const session = queries.createSession(convId);
-    queries.createEvent('session.created', { messageId: message.id, sessionId: session.id }, convId, session.id);
-    // Machine is authoritative — START event sets sessionId in context
-    execMachine.send(convId, { type: 'START', sessionId: session.id });
-    activeExecutions.set(convId, { pid: null, startTime: Date.now(), sessionId: session.id, lastActivity: Date.now() });
-    queries.setIsStreaming(convId, true);
-    broadcastSync({ type: 'streaming_start', sessionId: session.id, conversationId: convId, messageId: message.id, agentId, timestamp: Date.now() });
-    processMessageWithStreaming(convId, message.id, session.id, content, agentId, model, subAgent).catch(e => logError('startExecution', e, { convId }));
-    return session;
-  }
-
-  function enqueue(convId, content, agentId, model, messageId, subAgent) {
-    const item = { content, agentId, model, messageId, subAgent };
-    // Machine is authoritative for queue — ENQUEUE event adds to machine context.queue
-    execMachine.send(convId, { type: 'ENQUEUE', item });
-    // Keep messageQueues in sync for legacy REST endpoints
-    if (!messageQueues.has(convId)) messageQueues.set(convId, []);
-    messageQueues.get(convId).push(item);
-    const queueLength = execMachine.getQueue(convId).length;
-    broadcastSync({ type: 'queue_status', conversationId: convId, queueLength, messageId, timestamp: Date.now() });
-    return queueLength;
-  }
-
-  router.handle('msg.send', (p) => {
-    const conv = queries.getConversation(p.id);
-    if (!conv) notFound('Conversation not found');
-    const agentId = p.agentId || conv.agentType || conv.agentId || 'claude-code';
-    const model = p.model || conv.model || null;
-    const subAgent = p.subAgent || conv.subAgent || null;
-    const idempotencyKey = p.idempotencyKey || null;
-    const rawContent = p.content;
-    if (rawContent !== undefined && typeof rawContent !== 'string') {
-      console.warn(`[ws-validation] msg.send content is ${typeof rawContent}: ${JSON.stringify(rawContent).slice(0, 200)}`);
-      logError('ws-content-type', new TypeError(`non-string content in msg.send`), { method: 'msg.send', type: typeof rawContent });
-    }
-    p.content = typeof rawContent === 'string' ? rawContent : (rawContent ? JSON.stringify(rawContent) : '');
-    const message = queries.createMessage(p.id, 'user', p.content, idempotencyKey);
-    queries.createEvent('message.created', { role: 'user', messageId: message.id }, p.id);
-
-    // Machine is authoritative: gate on machine state, not Map
-    if (!execMachine.isActive(p.id)) {
-      broadcastSync({ type: 'message_created', conversationId: p.id, message, timestamp: Date.now() });
-      const session = startExecution(p.id, message, agentId, model, p.content, subAgent);
-      return { message, session, idempotencyKey };
-    }
-
-    const qp = enqueue(p.id, p.content, agentId, model, message.id, subAgent);
-    return { message, queued: true, queuePosition: qp, idempotencyKey };
-  });
-
-  router.handle('msg.get', (p) => {
-    const msg = queries.getMessage(p.messageId);
-    if (!msg || msg.conversationId !== p.id) notFound();
-    return { message: msg };
-  });
-
-  router.handle('msg.stream', (p) => {
-    p = validate(MsgStreamSchema, p);
-    const conv = queries.getConversation(p.id);
-    if (!conv) notFound('Conversation not found');
-    const rawContent = p.content || p.message;
-    if (rawContent !== undefined && typeof rawContent !== 'string') {
-      console.warn(`[ws-validation] msg.stream content is ${typeof rawContent}: ${JSON.stringify(rawContent).slice(0, 200)}`);
-      logError('ws-content-type', new TypeError(`non-string content in msg.stream`), { method: 'msg.stream', type: typeof rawContent });
-    }
-    const prompt = typeof rawContent === 'string' ? rawContent : (rawContent ? JSON.stringify(rawContent) : '');
-    const agentId = p.agentId || conv.agentType || conv.agentId || 'claude-code';
-    const model = p.model || conv.model || null;
-    const subAgent = p.subAgent || conv.subAgent || null;
-    const userMessage = queries.createMessage(p.id, 'user', prompt);
-    queries.createEvent('message.created', { role: 'user', messageId: userMessage.id }, p.id);
-
-    // Machine is authoritative: gate on machine state, not Map
-    if (!execMachine.isActive(p.id)) {
-      broadcastSync({ type: 'message_created', conversationId: p.id, message: userMessage, timestamp: Date.now() });
-      const session = startExecution(p.id, userMessage, agentId, model, prompt, subAgent);
-      return { message: userMessage, session, streamId: session.id };
-    }
-
-    const qp = enqueue(p.id, prompt, agentId, model, userMessage.id, subAgent);
-    const seq = getNextQueueSeq(p.id);
-    broadcastSync({
-      type: 'queue_status',
-      conversationId: p.id,
-      queueLength: execMachine.getQueue(p.id).length,
-      seq,
-      timestamp: Date.now()
-    });
-    return { message: userMessage, queued: true, queuePosition: qp };
-  });
-
-  router.handle('q.ls', (p) => {
-    if (!queries.getConversation(p.id)) notFound('Conversation not found');
-    // Read queue from machine context (authoritative), fall back to Map for compatibility
-    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');
-    // Remove from both machine and Map
-    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');
-    // Update machine queue via direct send
-    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 };
-  });
 }