@dalmasonto/taskflow-mcp 1.0.7 → 1.0.9

package/dist/db.js

@@ -103,6 +103,7 @@ function initSchema(db) {
       sender_name TEXT NOT NULL DEFAULT 'unknown',
       recipient_name TEXT NOT NULL DEFAULT 'user',
       status TEXT NOT NULL DEFAULT 'pending',
+      source TEXT NOT NULL DEFAULT 'mcp',
       created_at TEXT NOT NULL,
       answered_at TEXT
     );
@@ -146,6 +147,9 @@ function initSchema(db) {
     if (!colNames.has('recipient_name')) {
         db.exec("ALTER TABLE agent_messages ADD COLUMN recipient_name TEXT NOT NULL DEFAULT 'user'");
     }
+    if (!colNames.has('source')) {
+        db.exec("ALTER TABLE agent_messages ADD COLUMN source TEXT NOT NULL DEFAULT 'mcp'");
+    }
     // Migration: make agent_messages.project_id nullable if it was NOT NULL
     try {
         const tableInfo = db.prepare("SELECT sql FROM sqlite_master WHERE name = 'agent_messages'").get();
@@ -163,13 +167,14 @@ function initSchema(db) {
           sender_name TEXT NOT NULL DEFAULT 'unknown',
           recipient_name TEXT NOT NULL DEFAULT 'user',
           status TEXT NOT NULL DEFAULT 'pending',
+          source TEXT NOT NULL DEFAULT 'mcp',
           created_at TEXT NOT NULL,
           answered_at TEXT
         );
         INSERT INTO agent_messages_new SELECT
           id, project_id, question, context, choices, response, agent_pid, delivered,
           COALESCE(sender_name, 'unknown'), COALESCE(recipient_name, 'user'),
-          status, created_at, answered_at
+          status, COALESCE(source, 'mcp'), created_at, answered_at
         FROM agent_messages;
         DROP TABLE agent_messages;
         ALTER TABLE agent_messages_new RENAME TO agent_messages;

package/dist/index.js

@@ -72,17 +72,15 @@ if (!httpOnly) {
     const { registerAgent, unregisterAgent } = await import('./agent-registry.js');
     // Auto-register this agent
     const agentName = registerAgent();
+    const agentPid = process.ppid;
     console.error(`[agent] registered as "${agentName}"`);
-    // Graceful shutdown — mark agent as disconnected
-    const cleanup = () => { try {
+    let cleanup = () => { try {
         unregisterAgent(agentName);
     }
     catch { } process.exit(0); };
     process.on('SIGINT', cleanup);
     process.on('SIGTERM', cleanup);
-    // Background poller: deliver messages to this agent's terminal via tmux
-    const POLL_INTERVAL = 3000;
-    const agentPid = process.ppid;
+    // Tmux bridge: SSE listener for instant delivery + capture for terminal→chat
     let tmuxTarget = null;
     try {
         const { execSync: exec } = await import('child_process');
@@ -95,53 +93,25 @@ if (!httpOnly) {
                 break;
             }
         }
-        if (tmuxTarget)
-            console.error(`[inject] tmux pane ${tmuxTarget} for agent "${agentName}"`);
-        else
-            console.error('[inject] agent not in tmux — terminal injection disabled');
     }
     catch {
-        console.error('[inject] tmux not available');
+        console.error('[bridge] tmux not available');
     }
     if (tmuxTarget) {
-        const { execSync: exec } = await import('child_process');
-        const target = tmuxTarget;
-        setInterval(() => {
-            try {
-                const db = getDb();
-                // Check for messages addressed to this agent (from user or other agents)
-                // AND for answered questions this agent sent (inbox responses)
-                // Check by agent name AND by agent_pid (backward compat with old messages)
-                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')
-          )`).all(agentName, agentName, agentPid);
-                for (const msg of incoming) {
-                    db.prepare('UPDATE agent_messages SET delivered = 1 WHERE id = ?').run(msg.id);
-                    let text;
-                    if (msg.recipient_name === agentName && msg.sender_name === 'user') {
-                        text = `[Message from User]: ${msg.question}`;
-                    }
-                    else if (msg.recipient_name === agentName && msg.sender_name !== 'user') {
-                        text = `[Message from ${msg.sender_name}]: ${msg.question}`;
-                    }
-                    else if (msg.status === 'answered' && msg.response) {
-                        text = `[Inbox Response] to "${msg.question.slice(0, 60)}": ${msg.response}`;
-                    }
-                    else {
-                        continue;
-                    }
-                    try {
-                        exec(`tmux send-keys -t ${target} ${JSON.stringify(text)} Enter`, { stdio: 'ignore', timeout: 5000 });
-                        console.error(`[inject] delivered message ${msg.id} to tmux pane ${target}`);
-                    }
-                    catch (err) {
-                        console.error(`[inject] tmux send-keys failed for message ${msg.id}:`, err);
-                    }
-                }
-            }
-            catch { /* ignore */ }
-        }, POLL_INTERVAL);
+        const { startTmuxBridge } = await import('./tmux-bridge.js');
+        const stopBridge = startTmuxBridge({
+            agentName,
+            agentPid,
+            tmuxPane: tmuxTarget,
+        });
+        const originalCleanup = cleanup;
+        cleanup = () => { stopBridge(); originalCleanup(); };
+        process.removeListener('SIGINT', originalCleanup);
+        process.removeListener('SIGTERM', originalCleanup);
+        process.on('SIGINT', cleanup);
+        process.on('SIGTERM', cleanup);
+    }
+    else {
+        console.error('[bridge] agent not in tmux — bridge disabled');
     }
 }

package/dist/sse.js

@@ -317,18 +317,20 @@ export async function startSSEServer() {
             jsonResponse(res, 200, updated);
             return;
         }
-        // POST /api/agent-messages/send — user sends a message to an agent
+        // POST /api/agent-messages/send — send a message (from user UI or capture system)
         if (req.url === '/api/agent-messages/send' && req.method === 'POST') {
             const db = getDb();
             const body = JSON.parse(await readBody(req));
-            const { recipient, message: msgText, projectId } = body;
+            const { recipient, message: msgText, projectId, source: msgSource, senderName } = body;
             if (!recipient || !msgText) {
                 jsonResponse(res, 400, { error: 'recipient and message are required' });
                 return;
             }
+            const source = msgSource || 'ui';
+            const sender = senderName || 'user';
             const ts = new Date().toISOString();
-            const result = db.prepare(`INSERT INTO agent_messages (project_id, question, sender_name, recipient_name, status, created_at)
-         VALUES (?, ?, 'user', ?, 'pending', ?)`).run(projectId ?? null, msgText, recipient, ts);
+            const result = db.prepare(`INSERT INTO agent_messages (project_id, question, sender_name, recipient_name, source, status, created_at)
+         VALUES (?, ?, ?, ?, ?, 'pending', ?)`).run(projectId ?? null, msgText, sender, recipient, source, ts);
             const id = result.lastInsertRowid;
             const msg = db.prepare('SELECT * FROM agent_messages WHERE id = ?').get(id);
             broadcast('agent_question', { entity: 'agent_message', action: 'agent_question', payload: msg });

package/dist/tmux-bridge.d.ts

@@ -0,0 +1,11 @@
+interface BridgeOptions {
+    agentName: string;
+    agentPid: number;
+    tmuxPane: string;
+}
+/**
+ * Start the tmux bridge: SSE listener for instant message delivery.
+ * Returns a cleanup function for graceful shutdown.
+ */
+export declare function startTmuxBridge(options: BridgeOptions): () => void;
+export {};

package/dist/tmux-bridge.js

@@ -0,0 +1,134 @@
+import { execSync } from 'child_process';
+import { getDb } from './db.js';
+import { getActivePort } from './sse.js';
+import http from 'http';
+// ─── SSE Listener (replaces the 3s poller) ───────────────────────────
+function startSSEListener(options) {
+    const { agentName, agentPid, tmuxPane } = options;
+    const port = getActivePort();
+    function connect() {
+        const req = http.get(`http://localhost:${port}/events`, (res) => {
+            let buffer = '';
+            res.on('data', (chunk) => {
+                buffer += chunk.toString();
+                const lines = buffer.split('\n');
+                buffer = lines.pop() || '';
+                let eventType = '';
+                for (const line of lines) {
+                    if (line.startsWith('event: ')) {
+                        eventType = line.slice(7).trim();
+                    }
+                    else if (line.startsWith('data: ') && eventType) {
+                        try {
+                            const data = JSON.parse(line.slice(6));
+                            handleSSEEvent(eventType, data, options);
+                        }
+                        catch { /* malformed JSON */ }
+                        eventType = '';
+                    }
+                }
+            });
+            res.on('end', () => {
+                console.error('[bridge] SSE connection closed, reconnecting in 3s...');
+                setTimeout(connect, 3000);
+            });
+            res.on('error', () => {
+                console.error('[bridge] SSE connection error, reconnecting in 3s...');
+                setTimeout(connect, 3000);
+            });
+        });
+        req.on('error', () => {
+            console.error('[bridge] SSE connect failed, retrying in 3s...');
+            setTimeout(connect, 3000);
+        });
+    }
+    // Initial sweep: deliver any undelivered messages from before SSE connected
+    deliverUndelivered(options);
+    connect();
+}
+function handleSSEEvent(event, data, options) {
+    const { agentName, agentPid, tmuxPane } = options;
+    const payload = data.payload;
+    if (!payload)
+        return;
+    if (event === 'agent_question') {
+        const recipient = payload.recipient_name;
+        const sender = payload.sender_name;
+        const status = payload.status;
+        const id = payload.id;
+        const delivered = payload.delivered;
+        if (recipient !== agentName || status !== 'pending' || delivered === 1)
+            return;
+        let text;
+        if (sender === 'user') {
+            text = `[Message from User]: ${payload.question}`;
+        }
+        else {
+            text = `[Message from ${sender}]: ${payload.question}`;
+        }
+        injectAndMarkDelivered(id, text, tmuxPane);
+    }
+    if (event === 'agent_question_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';
+        if (!isOurs || status !== 'answered' || delivered === 1)
+            return;
+        const question = (payload.question || '').slice(0, 60);
+        const response = payload.response;
+        const text = `[Inbox Response] to "${question}": ${response}`;
+        injectAndMarkDelivered(id, text, tmuxPane);
+    }
+}
+function injectAndMarkDelivered(id, text, tmuxPane) {
+    const db = getDb();
+    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 });
+        console.error(`[bridge] delivered message ${id} to tmux pane ${tmuxPane}`);
+    }
+    catch (err) {
+        console.error(`[bridge] tmux send-keys failed for message ${id}:`, err);
+    }
+}
+function deliverUndelivered(options) {
+    const { agentName, agentPid, tmuxPane } = 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')
+    )`).all(agentName, agentName, agentPid);
+    for (const msg of incoming) {
+        let text;
+        if (msg.recipient_name === agentName && msg.sender_name === 'user') {
+            text = `[Message from User]: ${msg.question}`;
+        }
+        else if (msg.recipient_name === agentName && msg.sender_name !== 'user') {
+            text = `[Message from ${msg.sender_name}]: ${msg.question}`;
+        }
+        else if (msg.status === 'answered' && msg.response) {
+            text = `[Inbox Response] to "${msg.question.slice(0, 60)}": ${msg.response}`;
+        }
+        else {
+            continue;
+        }
+        injectAndMarkDelivered(msg.id, text, tmuxPane);
+    }
+}
+// ─── Public API ──────────────────────────────────────────────────────
+/**
+ * Start the tmux bridge: SSE listener for instant message delivery.
+ * Returns a cleanup function for graceful shutdown.
+ */
+export function startTmuxBridge(options) {
+    startSSEListener(options);
+    console.error(`[bridge] tmux bridge active for agent "${options.agentName}" on pane ${options.tmuxPane}`);
+    return () => {
+        // SSE connection will close when process exits
+    };
+}

package/dist/tools/agent-inbox.js

@@ -31,8 +31,8 @@ export function registerAgentInboxTools(server) {
             return errorResponse(`Project ${params.project_id} not found`, 'NOT_FOUND');
         const senderName = ensureRegistered();
         const ts = now();
-        const result = db.prepare(`INSERT INTO agent_messages (project_id, question, context, choices, sender_name, recipient_name, agent_pid, status, created_at)
-         VALUES (?, ?, ?, ?, ?, 'user', ?, 'pending', ?)`).run(params.project_id, params.question, params.context ?? null, params.choices ? JSON.stringify(params.choices) : null, senderName, process.ppid, ts);
+        const result = db.prepare(`INSERT INTO agent_messages (project_id, question, context, choices, sender_name, recipient_name, agent_pid, source, status, created_at)
+         VALUES (?, ?, ?, ?, ?, 'user', ?, 'mcp', 'pending', ?)`).run(params.project_id, params.question, params.context ?? null, params.choices ? JSON.stringify(params.choices) : null, senderName, process.ppid, ts);
         const id = result.lastInsertRowid;
         const message = db.prepare('SELECT * FROM agent_messages WHERE id = ?').get(id);
         broadcastChange('agent_message', 'agent_question', message);
@@ -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).', {
@@ -73,13 +75,66 @@ export function registerAgentInboxTools(server) {
         if (!recipient)
             return errorResponse(`Agent "${params.recipient}" not found`, 'NOT_FOUND');
         const ts = now();
-        const result = db.prepare(`INSERT INTO agent_messages (project_id, question, context, sender_name, recipient_name, status, created_at)
-         VALUES (NULL, ?, ?, ?, ?, 'pending', ?)`).run(params.message, params.context ?? null, senderName, params.recipient, ts);
+        const result = db.prepare(`INSERT INTO agent_messages (project_id, question, context, sender_name, recipient_name, source, status, created_at)
+         VALUES (NULL, ?, ?, ?, ?, 'mcp', 'pending', ?)`).run(params.message, params.context ?? null, senderName, params.recipient, ts);
         const id = result.lastInsertRowid;
         const msg = db.prepare('SELECT * FROM agent_messages WHERE id = ?').get(id);
         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 = ? 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.7",
+  "version": "1.0.9",
   "description": "MCP server for TaskFlow — manage projects, tasks, timers, analytics via AI agents",
   "type": "module",
   "main": "dist/index.js",