agentgui 1.0.930 → 1.0.932

package/lib/routes-threads.js

@@ -1,100 +0,0 @@
-export function register(deps) {
-  const { sendJSON, parseBody, queries } = deps;
-  const routes = {};
-
-  routes['POST /api/threads'] = async (req, res) => {
-    try {
-      const body = await parseBody(req);
-      sendJSON(req, res, 201, queries.createThread(body.metadata || {}));
-    } catch (err) {
-      sendJSON(req, res, 422, { error: err.message, type: 'validation_error' });
-    }
-  };
-
-  routes['POST /api/threads/search'] = async (req, res) => {
-    try {
-      sendJSON(req, res, 200, queries.searchThreads(await parseBody(req)));
-    } catch (err) {
-      sendJSON(req, res, 422, { error: err.message, type: 'validation_error' });
-    }
-  };
-
-  routes['_match'] = (method, pathOnly) => {
-    const key = `${method} ${pathOnly}`;
-    if (routes[key]) return routes[key];
-    let m;
-    if ((m = pathOnly.match(/^\/api\/threads\/([a-f0-9-]{36})$/))) {
-      if (method === 'GET') return (req, res) => handleGetThread(req, res, m[1]);
-      if (method === 'PATCH') return (req, res) => handlePatchThread(req, res, m[1]);
-      if (method === 'DELETE') return (req, res) => handleDeleteThread(req, res, m[1]);
-    }
-    if (method === 'GET' && (m = pathOnly.match(/^\/api\/threads\/([a-f0-9-]{36})\/history$/)))
-      return (req, res) => handleThreadHistory(req, res, m[1]);
-    if (method === 'POST' && (m = pathOnly.match(/^\/api\/threads\/([a-f0-9-]{36})\/copy$/)))
-      return (req, res) => handleThreadCopy(req, res, m[1]);
-    if (method === 'POST' && pathOnly.match(/^\/api\/threads\/([a-f0-9-]{36})\/runs\/stream$/))
-      return (req, res) => { res.writeHead(410); res.end(JSON.stringify({ error: 'SSE removed, use WebSocket' })); };
-    if (method === 'GET' && pathOnly.match(/^\/api\/threads\/([a-f0-9-]{36})\/runs\/([a-f0-9-]{36})\/stream$/))
-      return (req, res) => { res.writeHead(410); res.end(JSON.stringify({ error: 'SSE removed, use WebSocket' })); };
-    return null;
-  };
-
-  async function handleGetThread(req, res, threadId) {
-    try {
-      const thread = queries.getThread(threadId);
-      if (!thread) sendJSON(req, res, 404, { error: 'Thread not found', type: 'not_found' });
-      else sendJSON(req, res, 200, thread);
-    } catch (err) {
-      sendJSON(req, res, 500, { error: err.message, type: 'internal_error' });
-    }
-  }
-
-  async function handlePatchThread(req, res, threadId) {
-    try {
-      sendJSON(req, res, 200, queries.patchThread(threadId, await parseBody(req)));
-    } catch (err) {
-      const code = err.message.includes('not found') ? 404 : 422;
-      sendJSON(req, res, code, { error: err.message, type: code === 404 ? 'not_found' : 'validation_error' });
-    }
-  }
-
-  async function handleDeleteThread(req, res, threadId) {
-    try {
-      queries.deleteThread(threadId);
-      res.writeHead(204); res.end();
-    } catch (err) {
-      if (err.message.includes('not found')) sendJSON(req, res, 404, { error: err.message, type: 'not_found' });
-      else if (err.message.includes('pending runs')) sendJSON(req, res, 409, { error: err.message, type: 'conflict' });
-      else sendJSON(req, res, 500, { error: err.message, type: 'internal_error' });
-    }
-  }
-
-  async function handleThreadHistory(req, res, threadId) {
-    try {
-      const url = new URL(req.url, `http://${req.headers.host}`);
-      const limit = parseInt(url.searchParams.get('limit') || '50', 10);
-      const before = url.searchParams.get('before') || null;
-      let offset = 0;
-      if (before) { const parsed = parseInt(before, 10); if (!isNaN(parsed)) offset = parsed; }
-      const result = queries.getThreadHistory(threadId, limit, offset);
-      sendJSON(req, res, 200, { states: result.states, next_cursor: result.hasMore ? String(offset + limit) : null });
-    } catch (err) {
-      const code = err.message.includes('not found') ? 404 : 422;
-      sendJSON(req, res, code, { error: err.message, type: code === 404 ? 'not_found' : 'validation_error' });
-    }
-  }
-
-  async function handleThreadCopy(req, res, sourceThreadId) {
-    try {
-      const body = await parseBody(req);
-      const newThread = queries.copyThread(sourceThreadId);
-      if (body.metadata) sendJSON(req, res, 201, queries.patchThread(newThread.thread_id, { metadata: body.metadata }));
-      else sendJSON(req, res, 201, newThread);
-    } catch (err) {
-      const code = err.message.includes('not found') ? 404 : 500;
-      sendJSON(req, res, code, { error: err.message, type: code === 404 ? 'not_found' : 'internal_error' });
-    }
-  }
-
-  return routes;
-}

package/lib/routes-util.js

@@ -1,110 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import os from 'os';
-import { execSync } from 'child_process';
-
-export function register(deps) {
-  const { sendJSON, parseBody, queries, STARTUP_CWD, PKG_VERSION } = deps;
-  const routes = {};
-
-  routes['GET /api/import/claude-code'] = async (req, res) => {
-    const result = queries.importClaudeCodeConversations();
-    sendJSON(req, res, 200, { imported: result });
-  };
-
-  routes['GET /api/discover/claude-code'] = async (req, res) => {
-    const discovered = queries.discoverClaudeCodeConversations();
-    sendJSON(req, res, 200, { discovered });
-  };
-
-  routes['GET /api/home'] = async (req, res) => {
-    sendJSON(req, res, 200, { home: os.homedir(), cwd: STARTUP_CWD });
-  };
-
-  routes['GET /api/version'] = async (req, res) => {
-    sendJSON(req, res, 200, { version: PKG_VERSION });
-  };
-
-  routes['POST /api/clone'] = async (req, res) => {
-    const body = await parseBody(req);
-    const repo = (body.repo || '').trim();
-    if (!repo || !/^[a-zA-Z0-9_.-]+\/[a-zA-Z0-9_.-]+$/.test(repo)) {
-      sendJSON(req, res, 400, { error: 'Invalid repo format. Use org/repo or user/repo' });
-      return;
-    }
-    const cloneDir = STARTUP_CWD || os.homedir();
-    const repoName = repo.split('/')[1];
-    const targetPath = path.join(cloneDir, repoName);
-    if (fs.existsSync(targetPath)) {
-      sendJSON(req, res, 409, { error: `Directory already exists: ${repoName}`, path: targetPath });
-      return;
-    }
-    try {
-      const isWindows = os.platform() === 'win32';
-      execSync('git clone https://github.com/' + repo + '.git', {
-        cwd: cloneDir, encoding: 'utf-8', timeout: 120000,
-        stdio: ['pipe', 'pipe', 'pipe'],
-        env: { ...process.env, GIT_TERMINAL_PROMPT: '0' },
-        shell: isWindows
-      });
-      sendJSON(req, res, 200, { ok: true, repo, path: targetPath, name: repoName });
-    } catch (err) {
-      sendJSON(req, res, 500, { error: (err.stderr || err.message || 'Clone failed').trim() });
-    }
-  };
-
-  routes['POST /api/folders'] = async (req, res) => {
-    const body = await parseBody(req);
-    const folderPath = body.path || STARTUP_CWD;
-    try {
-      const expandedPath = path.resolve(folderPath.startsWith('~') ? folderPath.replace('~', os.homedir()) : folderPath);
-      if (!expandedPath.startsWith(os.homedir()) && !expandedPath.startsWith(STARTUP_CWD) && expandedPath !== '/') {
-        sendJSON(req, res, 403, { error: 'Path outside allowed directories' });
-        return;
-      }
-      const entries = fs.readdirSync(expandedPath, { withFileTypes: true });
-      const folders = entries
-        .filter(e => e.isDirectory() && !e.name.startsWith('.'))
-        .map(e => ({ name: e.name }))
-        .sort((a, b) => a.name.localeCompare(b.name));
-      sendJSON(req, res, 200, { folders });
-    } catch (err) {
-      sendJSON(req, res, 400, { error: err.message });
-    }
-  };
-
-  routes['GET /api/git/check-remote-ownership'] = async (req, res) => {
-    try {
-      const isWindows = os.platform() === 'win32';
-      const result = execSync('git remote get-url origin' + (isWindows ? '' : ' 2>/dev/null'), { encoding: 'utf-8', cwd: STARTUP_CWD, shell: isWindows });
-      const remoteUrl = result.trim();
-      const statusResult = execSync('git status --porcelain' + (isWindows ? '' : ' 2>/dev/null'), { encoding: 'utf-8', cwd: STARTUP_CWD, shell: isWindows });
-      const hasChanges = statusResult.trim().length > 0;
-      const unpushedResult = execSync('git rev-list --count --not --remotes' + (isWindows ? '' : ' 2>/dev/null'), { encoding: 'utf-8', cwd: STARTUP_CWD, shell: isWindows });
-      const hasUnpushed = parseInt(unpushedResult.trim() || '0', 10) > 0;
-      const ownsRemote = !remoteUrl.includes('github.com/') || remoteUrl.includes(process.env.GITHUB_USER || '');
-      sendJSON(req, res, 200, { ownsRemote, hasChanges, hasUnpushed, remoteUrl });
-    } catch {
-      sendJSON(req, res, 200, { ownsRemote: false, hasChanges: false, hasUnpushed: false, remoteUrl: '' });
-    }
-  };
-
-  routes['POST /api/git/push'] = async (req, res) => {
-    try {
-      const isWindows = os.platform() === 'win32';
-      const gitCommand = isWindows
-        ? 'git add -A & git commit -m "Auto-commit" & git push'
-        : 'git add -A && git commit -m "Auto-commit" && git push';
-      execSync(gitCommand, { encoding: 'utf-8', cwd: STARTUP_CWD, shell: isWindows });
-      sendJSON(req, res, 200, { success: true });
-    } catch (err) {
-      sendJSON(req, res, 500, { error: err.message });
-    }
-  };
-
-  routes['_match'] = (method, pathOnly) => {
-    return routes[`${method} ${pathOnly}`] || null;
-  };
-
-  return routes;
-}

package/lib/ws-handlers-conv.js

@@ -1,138 +0,0 @@
-import path from 'path';
-import os from 'os';
-import { z } from 'zod';
-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();
-
-export function register(router, deps) {
-  const { queries, activeExecutions, rateLimitState,
-    broadcastSync, processMessageWithStreaming, cleanupExecution,
-    getJsonlWatcher = () => null } = deps;
-
-  router.handle('conv.ls', (p) => {
-    let conversations = queries.getConversationsList();
-    for (const c of conversations) { if (c.isStreaming && !execMachine.isActive(c.id)) c.isStreaming = 0; }
-    if (p && p.tag) conversations = conversations.filter(c => c.tags && c.tags.split(',').includes(p.tag));
-    return { conversations };
-  });
-
-  router.handle('conv.tags', () => {
-    const convs = queries.getConversationsList();
-    const tagSet = new Set();
-    for (const c of convs) { if (c.tags) c.tags.split(',').forEach(t => { if (t.trim()) tagSet.add(t.trim()); }); }
-    return { tags: [...tagSet].sort() };
-  });
-
-  router.handle('conv.new', (p) => {
-    p = validate(ConvNewSchema, p);
-    const wd = p.workingDirectory ? path.resolve(expandTilde(p.workingDirectory)) : null;
-    const conv = queries.createConversation(p.agentId, p.title, wd, p.model || null, p.subAgent || null);
-    queries.createEvent('conversation.created', { agentId: p.agentId, workingDirectory: conv.workingDirectory, model: conv.model, subAgent: conv.subAgent }, conv.id);
-    broadcastSync({ type: 'conversation_created', conversation: conv });
-    return { conversation: conv };
-  });
-
-  router.handle('conv.get', (p) => {
-    const conv = queries.getConversation(p.id);
-    if (!conv) notFound();
-    const machineSnap = execMachine.snapshot(p.id);
-    return { conversation: conv, isActivelyStreaming: execMachine.isActive(p.id), latestSession: queries.getLatestSession(p.id), executionState: machineSnap?.value || 'idle' };
-  });
-
-  router.handle('conv.upd', (p) => {
-    p = validate(ConvUpdSchema, p);
-    const { id, ...data } = p;
-    if (data.workingDirectory) data.workingDirectory = path.resolve(data.workingDirectory);
-    const conv = queries.updateConversation(id, data);
-    if (!conv) notFound('Conversation not found');
-    queries.createEvent('conversation.updated', data, id);
-    broadcastSync({ type: 'conversation_updated', conversation: conv });
-    return { conversation: conv };
-  });
-
-  router.handle('conv.del', (p) => {
-    cleanupExecution(p.id);
-    execMachine.remove(p.id);
-    if (!queries.deleteConversation(p.id)) notFound();
-    getJsonlWatcher()?.removeConversation(p.id);
-    broadcastSync({ type: 'conversation_deleted', conversationId: p.id });
-    return { deleted: true };
-  });
-
-  router.handle('conv.del.all', (p) => {
-    const convs = queries.getConversationsList();
-    for (const c of convs) { cleanupExecution(c.id); execMachine.remove(c.id); }
-    if (!queries.deleteAllConversations()) fail(500, 'Failed to delete all conversations');
-    getJsonlWatcher()?.removeAllConversations();
-    broadcastSync({ type: 'all_conversations_deleted', timestamp: Date.now() });
-    return { deleted: true, message: 'All conversations deleted' };
-  });
-
-  router.handle('conv.full', (p) => {
-    const conv = queries.getConversation(p.id);
-    if (!conv) notFound();
-    const chunkLimit = Math.min(p.chunkLimit || 500, 5000);
-    const messageLimit = Math.min(p.messageLimit || 20, 100);
-    const totalChunks = queries.getConversationChunkCount(p.id);
-    const chunks = (p.allChunks || totalChunks <= chunkLimit)
-      ? queries.getConversationChunks(p.id) : queries.getRecentConversationChunks(p.id, chunkLimit);
-    const messagesResult = queries.getRecentMessages(p.id, messageLimit);
-    const machineSnap = execMachine.snapshot(p.id);
-    return {
-      conversation: conv,
-      isActivelyStreaming: execMachine.isActive(p.id),
-      executionState: machineSnap?.value || 'idle',
-      latestSession: queries.getLatestSession(p.id),
-      chunks,
-      totalChunks,
-      hasMoreChunks: totalChunks > chunkLimit,
-      messages: messagesResult.messages,
-      totalMessages: messagesResult.total,
-      hasMoreMessages: messagesResult.hasMore,
-      rateLimitInfo: rateLimitState.get(p.id) || null
-    };
-  });
-
-  router.handle('conv.chunks', (p) => {
-    if (!queries.getConversation(p.id)) notFound('Conversation not found');
-    const since = parseInt(p.since || '0');
-    const all = p.all === true || p.all === 'true';
-    const totalChunks = queries.getConversationChunkCount(p.id);
-    let chunks;
-    if (since > 0) {
-      chunks = queries.getConversationChunksSince(p.id, since);
-    } else if (all) {
-      chunks = queries.getConversationChunks(p.id);
-    } else {
-      chunks = queries.getRecentConversationChunks(p.id, 500);
-    }
-    return { ok: true, chunks, totalChunks };
-  });
-
-  router.handle('conv.chunks.earlier', (p) => {
-    if (!queries.getConversation(p.id)) notFound('Conversation not found');
-    const beforeTimestamp = parseInt(p.before || Date.now());
-    const limit = Math.min(p.limit || 500, 5000);
-    const result = queries.getChunksBefore(p.id, beforeTimestamp, limit);
-    return { ok: true, chunks: result.chunks, total: result.total, hasMore: result.hasMore, limit: result.limit };
-  });
-
-  router.handle('conv.reorder', (p) => {
-    if (!Array.isArray(p.order)) throw Object.assign(new Error('order array required'), { code: 400 });
-    for (let i = 0; i < p.order.length; i++) {
-      queries.updateConversationSortOrder(p.order[i], i);
-    }
-    return { ok: true };
-  });
-}

package/lib/ws-handlers-conv2.js

@@ -1,169 +0,0 @@
-import { z } from 'zod';
-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 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 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, rateLimitState,
-    broadcastSync, processMessageWithStreaming, cleanupExecution,
-    getJsonlWatcher = () => null, logError = () => {} } = deps;
-
-  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);
-    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;
-  }
-
-  router.handle('conv.export', (p) => {
-    const conv = queries.getConversation(p.id);
-    if (!conv) notFound();
-    const msgs = queries.getConversationMessages(p.id);
-    const format = p.format || 'markdown';
-    if (format === 'json') return { conversation: conv, messages: msgs };
-    let md = `# ${conv.title || 'Conversation'}\n\n`;
-    md += `Agent: ${conv.agentType || 'unknown'} | Created: ${new Date(conv.created_at).toISOString()}\n\n---\n\n`;
-    for (const m of msgs) {
-      const role = m.role === 'user' ? 'User' : 'Assistant';
-      md += `## ${role}\n\n`;
-      let content = m.content;
-      try { const parsed = JSON.parse(content); if (Array.isArray(parsed)) { content = parsed.map(b => b.text || b.content || JSON.stringify(b)).join('\n'); } } catch {}
-      md += content + '\n\n---\n\n';
-    }
-    return { markdown: md, title: conv.title };
-  });
-
-  router.handle('conv.import', (p) => {
-    if (!p.conversation || !p.messages) throw Object.assign(new Error('Missing conversation or messages'), { code: 400 });
-    const src = p.conversation;
-    const conv = queries.createConversation(
-      src.agentId || src.agentType || 'claude-code',
-      src.title || 'Imported Conversation',
-      src.workingDirectory || null,
-      src.model || null
-    );
-    for (const msg of p.messages) {
-      queries.createMessage(conv.id, msg.role || 'user', msg.content || '');
-    }
-    broadcastSync({ type: 'conversation_created', conversation: queries.getConversation(conv.id) });
-    return { conversation: queries.getConversation(conv.id), importedMessages: p.messages.length };
-  });
-
-  router.handle('conv.sync', (p) => {
-    const conv = queries.getConversation(p.id);
-    if (!conv) notFound();
-    const machineSnap = execMachine.snapshot(p.id);
-    const executionState = machineSnap?.value || 'idle';
-    const latestSession = queries.getLatestSession(p.id);
-    const sinceSeq = parseInt(p.sinceSeq || '-1');
-    const since = parseInt(p.since || '0');
-    let missedChunks = [];
-    if (latestSession && sinceSeq >= 0) {
-      missedChunks = queries.getChunksSinceSeq(latestSession.id, sinceSeq);
-    } else if (latestSession && since > 0) {
-      missedChunks = queries.getConversationChunksSince(p.id, since);
-    }
-    return {
-      conversation: conv,
-      executionState,
-      isActivelyStreaming: execMachine.isActive(p.id),
-      latestSession,
-      missedChunks,
-      missedCount: missedChunks.length,
-      queueLength: machineSnap?.context?.queue?.length || 0
-    };
-  });
-
-  router.handle('conv.search', (p) => {
-    if (!p.query || typeof p.query !== 'string' || p.query.trim().length < 2) return { results: [] };
-    const limit = Math.min(parseInt(p.limit || '50'), 200);
-    return { results: queries.searchMessages(p.query.trim(), limit) };
-  });
-
-  router.handle('conv.prune', (p) => {
-    const conv = queries.getConversation(p.id);
-    if (!conv) notFound();
-    const keep = Math.max(parseInt(p.keep || '500'), 100);
-    const sessions = queries.getConversationSessions(p.id);
-    if (!sessions || sessions.length === 0) return { pruned: 0 };
-    const latestSessionId = sessions[0]?.id;
-    let pruned = 0;
-    for (const sess of sessions) {
-      if (sess.id === latestSessionId) continue;
-      const count = queries.getSessionChunks(sess.id)?.length || 0;
-      if (count > 0) { queries.deleteSessionChunks(sess.id); pruned += count; }
-    }
-    return { pruned, kept: latestSessionId, sessionsProcessed: sessions.length };
-  });
-
-  router.handle('conv.cancel', (p) => {
-    if (!execMachine.isActive(p.id)) notFound('No active execution to cancel');
-    const ctx = execMachine.getContext(p.id);
-    const pid = ctx?.pid || activeExecutions.get(p.id)?.pid;
-    const sessionId = ctx?.sessionId || activeExecutions.get(p.id)?.sessionId;
-    if (pid) { try { process.kill(-pid, 'SIGKILL'); } catch { try { process.kill(pid, 'SIGKILL'); } catch {} } }
-    if (sessionId) queries.updateSession(sessionId, { status: 'interrupted', completed_at: Date.now() });
-    cleanupExecution(p.id, false);
-    broadcastSync({ type: 'streaming_complete', sessionId, conversationId: p.id, interrupted: true, timestamp: Date.now() });
-    return { ok: true, cancelled: true, conversationId: p.id, sessionId };
-  });
-
-  router.handle('conv.inject', (p) => {
-    const conv = queries.getConversation(p.id);
-    if (!conv) notFound('Conversation not found');
-    if (!p.content) fail(400, 'Missing content');
-    const message = queries.createMessage(p.id, 'user', '[INJECTED] ' + p.content);
-    if (!execMachine.isActive(p.id)) {
-      const agentId = conv.agentId || 'claude-code';
-      const session = queries.createSession(p.id, agentId, 'pending');
-      processMessageWithStreaming(p.id, message.id, session.id, message.content, agentId, conv.model || null, conv.subAgent || null);
-    }
-    return { ok: true, injected: true, conversationId: p.id, messageId: message.id };
-  });
-
-  router.handle('conv.steer', (p) => {
-    p = validate(ConvSteerSchema, p);
-    const conv = queries.getConversation(p.id);
-    if (!conv) notFound('Conversation not found');
-
-    if (!execMachine.isActive(p.id)) fail(409, 'No active execution to steer');
-
-    const ctx = execMachine.getContext(p.id);
-    const pid = ctx?.pid || activeExecutions.get(p.id)?.pid;
-    const sessionId = ctx?.sessionId || activeExecutions.get(p.id)?.sessionId;
-
-    if (pid) {
-      try { process.kill(-pid, 'SIGKILL'); } catch { try { process.kill(pid, 'SIGKILL'); } catch (e) {} }
-    }
-
-    if (sessionId) queries.updateSession(sessionId, { status: 'interrupted', completed_at: Date.now() });
-    cleanupExecution(p.id);
-
-    queries.setClaudeSessionId(p.id, null);
-
-    broadcastSync({ type: 'streaming_complete', sessionId, conversationId: p.id, interrupted: true, timestamp: Date.now() });
-
-    const agentId = conv.agentType || conv.agentId || 'claude-code';
-    const model = conv.model || null;
-    const subAgent = conv.subAgent || null;
-    const steerContent = typeof p.content === 'string' ? p.content : (p.content ? JSON.stringify(p.content) : '');
-    const message = queries.createMessage(p.id, 'user', steerContent);
-    queries.createEvent('message.created', { role: 'user', messageId: message.id }, p.id);
-    broadcastSync({ type: 'message_created', conversationId: p.id, message, timestamp: Date.now() });
-    startExecution(p.id, message, agentId, model, steerContent, subAgent);
-
-    return { ok: true, steered: true, conversationId: p.id, messageId: message.id };
-  });
-}

package/lib/ws-handlers-msg.js

@@ -1,121 +0,0 @@
-import { z } from 'zod';
-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 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 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();
-
-export function register(router, deps) {
-  const { queries, activeExecutions, messageQueues,
-    broadcastSync, processMessageWithStreaming, logError = () => {} } = deps;
-
-  const queueSeqByConv = new Map();
-  function getNextQueueSeq(conversationId) {
-    const current = queueSeqByConv.get(conversationId) || 0;
-    const next = current + 1;
-    queueSeqByConv.set(conversationId, next);
-    return next;
-  }
-
-  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);
-    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 };
-    execMachine.send(convId, { type: 'ENQUEUE', item });
-    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;
-  }
-
-  function normalizeContent(rawContent, method) {
-    if (rawContent !== undefined && typeof rawContent !== 'string') {
-      console.warn(`[ws-validation] ${method} content is ${typeof rawContent}: ${JSON.stringify(rawContent).slice(0, 200)}`);
-      logError('ws-content-type', new TypeError(`non-string content in ${method}`), { method, type: typeof rawContent });
-    }
-    return typeof rawContent === 'string' ? rawContent : (rawContent ? JSON.stringify(rawContent) : '');
-  }
-
-  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 };
-  });
-
-  router.handle('msg.get', (p) => {
-    const msg = queries.getMessage(p.messageId);
-    if (!msg || msg.conversationId !== p.id) notFound();
-    return { message: msg };
-  });
-
-  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;
-    p.content = normalizeContent(p.content, 'msg.send');
-    const message = queries.createMessage(p.id, 'user', p.content, idempotencyKey);
-    queries.createEvent('message.created', { role: 'user', messageId: message.id }, p.id);
-    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 };
-    }
-    broadcastSync({ type: 'message_created', conversationId: p.id, message, timestamp: Date.now() });
-    const qp = enqueue(p.id, p.content, agentId, model, message.id, subAgent);
-    return { message, queued: true, queuePosition: qp, idempotencyKey };
-  });
-
-  router.handle('msg.stream', (p) => {
-    p = validate(MsgStreamSchema, p);
-    const conv = queries.getConversation(p.id);
-    if (!conv) notFound('Conversation not found');
-    const prompt = normalizeContent(p.content || p.message, 'msg.stream');
-    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);
-    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 };
-    }
-    broadcastSync({ type: 'message_created', conversationId: p.id, message: userMessage, timestamp: Date.now() });
-    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 };
-  });
-}