@dalmasonto/taskflow-mcp 1.0.8 → 1.0.10

package/dist/agent-registry.js

@@ -47,14 +47,19 @@ export function registerAgent(options) {
     const agentPid = process.ppid;
     const projectPath = process.cwd();
     const folderName = projectPath.split('/').pop() || 'unknown';
-    // Check if this PID already has a registration — reuse it
+    // Check if this PID already has a registration — reuse it (or rename if customName provided)
     const existingByPid = db.prepare('SELECT * FROM agent_registry WHERE pid = ? AND status = ?').get(agentPid, 'connected');
     if (existingByPid) {
-        // Update tmux pane in case it changed, but keep the same name
         const tmuxPane = detectTmuxPane(agentPid);
         if (tmuxPane !== existingByPid.tmux_pane) {
             db.prepare('UPDATE agent_registry SET tmux_pane = ? WHERE id = ?').run(tmuxPane, existingByPid.id);
         }
+        // Allow renaming via customName
+        if (options?.customName && options.customName !== existingByPid.name) {
+            db.prepare('UPDATE agent_registry SET name = ? WHERE id = ?').run(options.customName, existingByPid.id);
+            broadcast('agent_connected', { entity: 'agent', action: 'agent_connected', payload: { ...existingByPid, name: options.customName, tmux_pane: tmuxPane ?? existingByPid.tmux_pane } });
+            return options.customName;
+        }
         return existingByPid.name;
     }
     // Clean up dead agents first to free up names

package/dist/sse.js

@@ -287,7 +287,7 @@ export async function startSSEServer() {
                 return;
             }
             const ts = new Date().toISOString();
-            db.prepare('UPDATE agent_messages SET response = ?, status = ?, answered_at = ? WHERE id = ?')
+            db.prepare('UPDATE agent_messages SET response = ?, status = ?, answered_at = ?, delivered = NULL WHERE id = ?')
                 .run(response, 'answered', ts, id);
             const updated = db.prepare('SELECT * FROM agent_messages WHERE id = ?').get(id);
             broadcast('agent_question_answered', { entity: 'agent_message', action: 'agent_question_answered', payload: updated });

package/dist/tmux-bridge.d.ts

@@ -4,7 +4,7 @@ interface BridgeOptions {
     tmuxPane: string;
 }
 /**
- * Start the tmux bridge: SSE listener for instant delivery + capture for terminal→chat.
+ * Start the tmux bridge: SSE listener for instant message delivery.
  * Returns a cleanup function for graceful shutdown.
  */
 export declare function startTmuxBridge(options: BridgeOptions): () => void;

package/dist/tmux-bridge.js

@@ -1,21 +1,7 @@
 import { execSync } from 'child_process';
-import { createReadStream, writeFileSync, unlinkSync, watchFile, unwatchFile, existsSync } from 'fs';
 import { getDb } from './db.js';
 import { getActivePort } from './sse.js';
 import http from 'http';
-// ─── UI-injected message prefixes (skip these in capture) ────────────
-const INJECTED_PREFIXES = [
-    '[Message from ',
-    '[Inbox Response]',
-];
-function isInjectedLine(line) {
-    return INJECTED_PREFIXES.some(prefix => line.startsWith(prefix));
-}
-// ─── Strip ANSI escape codes ─────────────────────────────────────────
-const ANSI_RE = /\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g;
-function stripAnsi(text) {
-    return text.replace(ANSI_RE, '');
-}
 // ─── SSE Listener (replaces the 3s poller) ───────────────────────────
 function startSSEListener(options) {
     const { agentName, agentPid, tmuxPane } = options;
@@ -66,7 +52,6 @@ function handleSSEEvent(event, data, options) {
     if (!payload)
         return;
     if (event === 'agent_question') {
-        // Incoming message addressed to this agent
         const recipient = payload.recipient_name;
         const sender = payload.sender_name;
         const status = payload.status;
@@ -84,14 +69,13 @@ function handleSSEEvent(event, data, options) {
         injectAndMarkDelivered(id, text, tmuxPane);
     }
     if (event === 'agent_question_answered') {
-        // A question this agent sent got answered
         const sender = payload.sender_name;
         const recipient = payload.recipient_name;
         const status = payload.status;
         const id = payload.id;
         const delivered = payload.delivered;
         const agentPidField = payload.agent_pid;
-        const isOurs = (sender === agentName || agentPidField === agentPid) && recipient === 'user';
+        const isOurs = sender === agentName || agentPidField === agentPid;
         if (!isOurs || status !== 'answered' || delivered === 1)
             return;
         const question = (payload.question || '').slice(0, 60);
@@ -105,6 +89,8 @@ function injectAndMarkDelivered(id, text, tmuxPane) {
     db.prepare('UPDATE agent_messages SET delivered = 1 WHERE id = ?').run(id);
     try {
         execSync(`tmux send-keys -t ${tmuxPane} ${JSON.stringify(text)} Enter`, { stdio: 'ignore', timeout: 5000 });
+        // Long text triggers tmux bracketed paste — delay then send extra Enter to confirm
+        execSync(`sleep 1 && tmux send-keys -t ${tmuxPane} Enter`, { stdio: 'ignore', timeout: 5000 });
         console.error(`[bridge] delivered message ${id} to tmux pane ${tmuxPane}`);
     }
     catch (err) {
@@ -116,8 +102,8 @@ function deliverUndelivered(options) {
     const db = getDb();
     const incoming = db.prepare(`SELECT * FROM agent_messages WHERE delivered IS NULL AND (
       (recipient_name = ? AND status = 'pending') OR
-      (sender_name = ? AND recipient_name = 'user' AND status = 'answered') OR
-      (agent_pid = ? AND recipient_name = 'user' AND status = 'answered')
+      (sender_name = ? AND status = 'answered') OR
+      (agent_pid = ? AND status = 'answered')
     )`).all(agentName, agentName, agentPid);
     for (const msg of incoming) {
         let text;
@@ -136,145 +122,15 @@ function deliverUndelivered(options) {
         injectAndMarkDelivered(msg.id, text, tmuxPane);
     }
 }
-// ─── Tmux Capture (terminal output → chat) ───────────────────────────
-const MAX_MESSAGE_LENGTH = 10000;
-const FLUSH_DELAY_MS = 2000;
-function startCapture(options) {
-    const { agentName, tmuxPane } = options;
-    const tmpFile = `/tmp/taskflow-capture-${agentName}.pipe`;
-    const port = getActivePort();
-    // Truncate/create the temp file
-    writeFileSync(tmpFile, '');
-    // Start tmux pipe-pane
-    try {
-        execSync(`tmux pipe-pane -t ${tmuxPane} -o "cat >> ${tmpFile}"`, { stdio: 'ignore' });
-        console.error(`[capture] started pipe-pane for ${tmuxPane} → ${tmpFile}`);
-    }
-    catch (err) {
-        console.error('[capture] failed to start pipe-pane:', err);
-        return () => { };
-    }
-    let buffer = '';
-    let flushTimer = null;
-    let readPosition = 0;
-    function flushBuffer() {
-        flushTimer = null;
-        if (!buffer.trim()) {
-            buffer = '';
-            return;
-        }
-        // Split into chunks if needed
-        const chunks = [];
-        let remaining = buffer;
-        while (remaining.length > MAX_MESSAGE_LENGTH) {
-            chunks.push(remaining.slice(0, MAX_MESSAGE_LENGTH));
-            remaining = remaining.slice(MAX_MESSAGE_LENGTH);
-        }
-        if (remaining.trim())
-            chunks.push(remaining);
-        buffer = '';
-        for (const chunk of chunks) {
-            postToChat(agentName, chunk, port);
-        }
-    }
-    function processNewData() {
-        if (!existsSync(tmpFile))
-            return;
-        const stream = createReadStream(tmpFile, {
-            start: readPosition,
-            encoding: 'utf-8',
-        });
-        let newData = '';
-        stream.on('data', (chunk) => { newData += chunk.toString(); });
-        stream.on('end', () => {
-            if (!newData)
-                return;
-            readPosition += Buffer.byteLength(newData);
-            const cleaned = stripAnsi(newData);
-            const lines = cleaned.split('\n');
-            const filtered = lines.filter(line => !isInjectedLine(line.trim()));
-            const text = filtered.join('\n');
-            if (text.trim()) {
-                buffer += text;
-                // Reset the flush timer on each new data
-                if (flushTimer)
-                    clearTimeout(flushTimer);
-                flushTimer = setTimeout(flushBuffer, FLUSH_DELAY_MS);
-            }
-        });
-        stream.on('error', () => { });
-    }
-    // Watch for file changes
-    watchFile(tmpFile, { interval: 500 }, () => {
-        processNewData();
-    });
-    // Cleanup function
-    return () => {
-        if (flushTimer)
-            clearTimeout(flushTimer);
-        // Flush any remaining buffer
-        if (buffer.trim()) {
-            const chunks = [];
-            let remaining = buffer;
-            while (remaining.length > MAX_MESSAGE_LENGTH) {
-                chunks.push(remaining.slice(0, MAX_MESSAGE_LENGTH));
-                remaining = remaining.slice(MAX_MESSAGE_LENGTH);
-            }
-            if (remaining.trim())
-                chunks.push(remaining);
-            buffer = '';
-            for (const chunk of chunks) {
-                postToChat(agentName, chunk, port);
-            }
-        }
-        unwatchFile(tmpFile);
-        try {
-            execSync(`tmux pipe-pane -t ${tmuxPane}`, { stdio: 'ignore' });
-        }
-        catch { }
-        try {
-            unlinkSync(tmpFile);
-        }
-        catch { }
-        console.error(`[capture] stopped for ${tmuxPane}`);
-    };
-}
-function postToChat(agentName, text, port) {
-    const body = JSON.stringify({
-        recipient: 'user',
-        message: text,
-        source: 'terminal',
-        senderName: agentName,
-    });
-    const req = http.request({
-        hostname: 'localhost',
-        port,
-        path: '/api/agent-messages/send',
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(body) },
-    }, (res) => {
-        // Drain the response
-        res.resume();
-        if (res.statusCode !== 200) {
-            console.error(`[capture] POST failed with status ${res.statusCode}`);
-        }
-    });
-    req.on('error', (err) => {
-        console.error('[capture] POST error:', err.message);
-    });
-    req.write(body);
-    req.end();
-}
 // ─── Public API ──────────────────────────────────────────────────────
 /**
- * Start the tmux bridge: SSE listener for instant delivery + capture for terminal→chat.
+ * Start the tmux bridge: SSE listener for instant message delivery.
  * Returns a cleanup function for graceful shutdown.
  */
 export function startTmuxBridge(options) {
     startSSEListener(options);
-    const stopCapture = startCapture(options);
     console.error(`[bridge] tmux bridge active for agent "${options.agentName}" on pane ${options.tmuxPane}`);
     return () => {
-        stopCapture();
+        // SSE connection will close when process exits
     };
 }

package/dist/tools/agent-inbox.js

@@ -44,8 +44,8 @@ export function registerAgentInboxTools(server) {
             message: `Question posted to Agent Inbox (id: ${id}). Use check_response(${id}) to retrieve the user's answer.`,
         });
     });
-    server.tool('check_response', 'Check if the user has responded to a previously posted agent question. Returns the response if answered, or status "pending" if still waiting.', {
-        message_id: z.number().describe('The agent message ID returned by ask_user'),
+    server.tool('check_response', 'Check if a previously posted question (via ask_user or ask_agent) has been answered. Returns the response if answered, or status "pending" if still waiting.', {
+        message_id: z.number().describe('The message ID returned by ask_user or ask_agent'),
     }, async (params) => {
         const db = getDb();
         const message = db.prepare('SELECT * FROM agent_messages WHERE id = ?').get(params.message_id);
@@ -54,12 +54,14 @@ export function registerAgentInboxTools(server) {
         if (message.status === 'answered') {
             return successResponse({
                 id: message.id, status: 'answered', response: message.response,
+                respondedBy: message.recipient_name,
                 question: message.question, answered_at: message.answered_at,
             });
         }
         return successResponse({
             id: message.id, status: 'pending', question: message.question,
-            message: 'User has not responded yet. Try again later or continue with other work.',
+            recipient: message.recipient_name,
+            message: 'No response yet. Try again later or continue with other work.',
         });
     });
     server.tool('send_to_agent', 'Send a message to another agent by name. Returns immediately. The recipient agent will receive the message in their terminal (if running in tmux).', {
@@ -80,6 +82,59 @@ export function registerAgentInboxTools(server) {
         broadcastChange('agent_message', 'agent_question', msg);
         return successResponse({ id, sender: senderName, recipient: params.recipient, status: 'pending' });
     });
+    server.tool('ask_agent', 'Ask another agent a question and wait for their response. Like ask_user but targets an agent. Returns the message ID — use check_response to poll for the answer. The recipient agent receives the question in their terminal (if in tmux) and can respond with respond_to_message.', {
+        recipient: z.string().describe('Name of the target agent (e.g. "backend", "task_flow:2")'),
+        question: z.string().describe('The question to ask'),
+        context: z.string().optional().describe('Markdown context — background info, code snippets, proposals'),
+        choices: z.array(z.string()).optional().describe('Optional quick-tap choices, e.g. ["Yes", "No", "Skip"]'),
+        project_id: z.number().optional().describe('Optional project ID to attach the question to'),
+    }, async (params) => {
+        const db = getDb();
+        const senderName = ensureRegistered();
+        const recipient = getAgent(params.recipient);
+        if (!recipient)
+            return errorResponse(`Agent "${params.recipient}" not found or not connected`, 'NOT_FOUND');
+        const ts = now();
+        const result = db.prepare(`INSERT INTO agent_messages (project_id, question, context, choices, sender_name, recipient_name, agent_pid, source, status, created_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, 'mcp', 'pending', ?)`).run(params.project_id ?? null, params.question, params.context ?? null, params.choices ? JSON.stringify(params.choices) : null, senderName, params.recipient, process.ppid, ts);
+        const id = result.lastInsertRowid;
+        const msg = db.prepare('SELECT * FROM agent_messages WHERE id = ?').get(id);
+        broadcastChange('agent_message', 'agent_question', msg);
+        logActivity('agent_question', `Asked ${params.recipient}: ${params.question}`, { entityType: 'agent_message', entityId: id });
+        return successResponse({
+            id,
+            status: 'pending',
+            sender: senderName,
+            recipient: params.recipient,
+            message: `Question sent to "${params.recipient}" (id: ${id}). Use check_response(${id}) to retrieve their answer.`,
+        });
+    });
+    server.tool('respond_to_message', 'Respond to a pending message addressed to this agent. Use check_messages to see incoming messages, then respond by message ID.', {
+        message_id: z.number().describe('The message ID to respond to (from check_messages)'),
+        response: z.string().describe('Your response text'),
+    }, async (params) => {
+        const db = getDb();
+        const name = ensureRegistered();
+        const message = db.prepare('SELECT * FROM agent_messages WHERE id = ?').get(params.message_id);
+        if (!message)
+            return errorResponse(`Message ${params.message_id} not found`, 'NOT_FOUND');
+        if (message.recipient_name !== name)
+            return errorResponse(`Message ${params.message_id} is not addressed to you`, 'VALIDATION_ERROR');
+        if (message.status !== 'pending')
+            return errorResponse(`Message ${params.message_id} is already ${message.status}`, 'VALIDATION_ERROR');
+        const ts = now();
+        db.prepare('UPDATE agent_messages SET response = ?, status = ?, answered_at = ?, delivered = NULL WHERE id = ?')
+            .run(params.response, 'answered', ts, params.message_id);
+        const updated = db.prepare('SELECT * FROM agent_messages WHERE id = ?').get(params.message_id);
+        broadcastChange('agent_message', 'agent_question_answered', updated);
+        logActivity('agent_question_answered', `Responded to ${message.sender_name}: ${params.response.slice(0, 80)}`, { entityType: 'agent_message', entityId: params.message_id });
+        return successResponse({
+            id: params.message_id,
+            status: 'answered',
+            sender: message.sender_name,
+            message: `Response sent to "${message.sender_name}".`,
+        });
+    });
     server.tool('check_messages', 'Check for incoming messages from users or other agents addressed to this agent.', {}, async () => {
         const db = getDb();
         const name = ensureRegistered();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dalmasonto/taskflow-mcp",
-  "version": "1.0.8",
+  "version": "1.0.10",
   "description": "MCP server for TaskFlow — manage projects, tasks, timers, analytics via AI agents",
   "type": "module",
   "main": "dist/index.js",