@dalmasonto/taskflow-mcp 1.0.7 → 1.0.8

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 delivery + capture for terminal→chat.
+ * Returns a cleanup function for graceful shutdown.
+ */
+export declare function startTmuxBridge(options: BridgeOptions): () => void;
+export {};

package/dist/tmux-bridge.js

@@ -0,0 +1,280 @@
+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;
+    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') {
+        // Incoming message addressed to this agent
+        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') {
+        // 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';
+        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);
+    }
+}
+// ─── 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.
+ * 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();
+    };
+}

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);
@@ -73,8 +73,8 @@ 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);

package/package.json

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