@dalmasonto/taskflow-mcp 1.0.16 → 1.0.18

package/dist/config.d.ts

@@ -5,6 +5,8 @@ export interface TaskFlowConfig {
     logLevel: 'debug' | 'info' | 'warn' | 'error';
     agentLivenessInterval: number;
     maxPortAttempts: number;
+    relayUrl: string;
+    relayPushToken: string;
 }
 /** Keys that live in the config file (not SQLite) */
 export declare const SERVER_CONFIG_KEYS: Set<string>;

package/dist/config.js

@@ -9,6 +9,8 @@ export const SERVER_CONFIG_KEYS = new Set([
     'logLevel',
     'agentLivenessInterval',
     'maxPortAttempts',
+    'relayUrl',
+    'relayPushToken',
 ]);
 // ─── defaults ────────────────────────────────────────────────────────
 const DEFAULTS = {
@@ -18,6 +20,8 @@ const DEFAULTS = {
     logLevel: 'info',
     agentLivenessInterval: 30_000,
     maxPortAttempts: 10,
+    relayUrl: '',
+    relayPushToken: '',
 };
 // ─── config file path ────────────────────────────────────────────────
 const CONFIG_PATH = resolve(homedir(), '.taskflow_config.json');
@@ -57,6 +61,12 @@ function applyCliAndEnvOverrides(config) {
     if (process.env.TASKFLOW_LOG_LEVEL) {
         config.logLevel = process.env.TASKFLOW_LOG_LEVEL;
     }
+    if (process.env.TASKFLOW_RELAY_URL) {
+        config.relayUrl = process.env.TASKFLOW_RELAY_URL;
+    }
+    if (process.env.TASKFLOW_RELAY_PUSH_TOKEN) {
+        config.relayPushToken = process.env.TASKFLOW_RELAY_PUSH_TOKEN;
+    }
     // CLI args take highest priority
     const portArgIdx = process.argv.indexOf('--port');
     if (portArgIdx !== -1 && process.argv[portArgIdx + 1]) {

package/dist/index.d.ts

@@ -1,2 +1,2 @@
 #!/usr/bin/env node
-export {};
+import 'dotenv/config';

package/dist/index.js

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import 'dotenv/config';
 import { getConfig } from './config.js';
 import { startSSEServer } from './sse.js';
 import { getDb } from './db.js';

package/dist/sse.d.ts

@@ -3,6 +3,7 @@ export declare function markSSEActive(): void;
 /**
  * Broadcast an SSE event. If this process owns the SSE server, send directly.
  * Otherwise, relay via HTTP to the process that does.
+ * Also pushes to the remote relay server if configured.
  */
 export declare function broadcast(event: string, data: object): void;
 /** Returns the port the SSE server is actively using */

package/dist/sse.js

@@ -5,6 +5,8 @@ import { logActivity } from './helpers.js';
 import { getConfig } from './config.js';
 const SERVICE_ID = 'taskflow-mcp';
 const PROBE_TIMEOUT_MS = 2000;
+// ─── Relay upstream config (from config file, env vars, or .env) ────
+const { relayUrl: RELAY_URL, relayPushToken: RELAY_PUSH_TOKEN } = getConfig();
 const clients = new Set();
 // ─── Event buffer for Last-Event-ID replay ──────────────────────────
 const EVENT_BUFFER_SIZE = 200;
@@ -51,6 +53,86 @@ function readBody(req) {
         req.on('end', () => resolve(body));
     });
 }
+const PROMPT_PATTERNS = [
+    /Esc to cancel/i,
+    /Tab to amend/i,
+    /\(y\/n\)/i,
+    /\(yes\/no\)/i,
+    /Do you want to/i,
+    /Allow .+ for this/i,
+];
+function detectPrompt(content) {
+    const tail = content.split('\n').slice(-25).join('\n');
+    const hints = [];
+    if (/Esc to cancel/i.test(tail))
+        hints.push('Esc to cancel');
+    if (/Tab to amend/i.test(tail))
+        hints.push('Tab to amend');
+    if (/shift\+tab/i.test(tail))
+        hints.push('Shift+Tab');
+    const detected = PROMPT_PATTERNS.some(p => p.test(tail));
+    return { detected, hints };
+}
+/** Fast string hash (djb2) for content change detection */
+function hashContent(str) {
+    let hash = 5381;
+    for (let i = 0; i < str.length; i++) {
+        hash = ((hash << 5) + hash + str.charCodeAt(i)) | 0;
+    }
+    return hash;
+}
+/**
+ * Unified terminal poller — single capture per agent, broadcasts:
+ * - terminal_capture: full pane content for UI rendering (only when changed)
+ * - agent_awaiting_input / agent_input_resolved: prompt state transitions
+ * - notification_created: when an agent first needs input
+ */
+function pollAgentTerminals(promptState, contentHashes) {
+    const db = getDb();
+    const agents = db.prepare("SELECT name, tmux_pane, status, pid FROM agent_registry WHERE status = 'connected' AND tmux_pane IS NOT NULL").all();
+    for (const agent of agents) {
+        try {
+            const content = execFileSync('tmux', ['capture-pane', '-p', '-S', '-', '-t', agent.tmux_pane], { timeout: 5000 }).toString();
+            // Only broadcast if content actually changed
+            const hash = hashContent(content);
+            const prevHash = contentHashes.get(agent.name);
+            if (hash !== prevHash) {
+                contentHashes.set(agent.name, hash);
+                broadcast('terminal_capture', {
+                    entity: 'terminal',
+                    action: 'terminal_capture',
+                    payload: { name: agent.name, pane: agent.tmux_pane, content },
+                });
+            }
+            // Prompt detection with state transitions (always check, even if content unchanged hash-wise)
+            const { detected, hints } = detectPrompt(content);
+            const wasAwaiting = promptState.get(agent.name) ?? false;
+            if (detected && !wasAwaiting) {
+                promptState.set(agent.name, true);
+                const ts = new Date().toISOString();
+                const hintsText = hints.length > 0 ? ` (${hints.join(' · ')})` : '';
+                db.prepare('INSERT INTO notifications (title, message, type, created_at) VALUES (?, ?, ?, ?)').run(`Agent "${agent.name}" needs input`, `A permission prompt is waiting for your response${hintsText}`, 'warning', ts);
+                const notification = db.prepare('SELECT * FROM notifications ORDER BY id DESC LIMIT 1').get();
+                broadcast('notification_created', { entity: 'notification', action: 'notification_created', payload: notification });
+                broadcast('agent_awaiting_input', { entity: 'agent', action: 'agent_awaiting_input', payload: { name: agent.name, hints, awaiting: true } });
+            }
+            else if (!detected && wasAwaiting) {
+                promptState.set(agent.name, false);
+                broadcast('agent_input_resolved', { entity: 'agent', action: 'agent_input_resolved', payload: { name: agent.name, awaiting: false } });
+            }
+        }
+        catch {
+            // tmux capture failed — agent pane may be gone
+        }
+    }
+    // Clean up agents that disconnected
+    for (const [name] of promptState) {
+        if (!agents.some(a => a.name === name)) {
+            promptState.delete(name);
+            contentHashes.delete(name);
+        }
+    }
+}
 export async function startSSEServer() {
     const server = createServer(async (req, res) => {
         // CORS headers for all requests
@@ -475,12 +557,37 @@ export async function startSSEServer() {
                         }
                     }
                 }, 30_000);
+                // Terminal capture & prompt detection — single capture loop for all agents
+                const promptState = new Map();
+                const contentHashes = new Map();
+                setInterval(() => {
+                    try {
+                        pollAgentTerminals(promptState, contentHashes);
+                    }
+                    catch { /* ignore */ }
+                }, 3_000);
                 if (port !== PREFERRED_PORT) {
                     console.log(`[SSE] listening on fallback port ${port} (preferred ${PREFERRED_PORT} was unavailable)`);
                 }
                 else {
                     console.log(`[SSE] listening on port ${port}`);
                 }
+                // Register with remote relay so it knows where to proxy commands
+                if (RELAY_URL && RELAY_PUSH_TOKEN) {
+                    const localUrl = `http://${cfg.host}:${port}`;
+                    fetch(`${RELAY_URL}/register`, {
+                        method: 'POST',
+                        headers: {
+                            'Content-Type': 'application/json',
+                            'Authorization': `Bearer ${RELAY_PUSH_TOKEN}`,
+                        },
+                        body: JSON.stringify({ url: localUrl }),
+                    }).then(() => {
+                        console.log(`[SSE] registered with relay at ${RELAY_URL}`);
+                    }).catch((err) => {
+                        console.error(`[SSE] relay registration failed: ${err.message}`);
+                    });
+                }
                 resolve();
             });
         }
@@ -504,6 +611,7 @@ export function markSSEActive() {
 /**
  * Broadcast an SSE event. If this process owns the SSE server, send directly.
  * Otherwise, relay via HTTP to the process that does.
+ * Also pushes to the remote relay server if configured.
  */
 export function broadcast(event, data) {
     if (sseServerActive && clients.size > 0) {
@@ -520,6 +628,17 @@ export function broadcast(event, data) {
             console.error(`[SSE] broadcast relay to port ${activePort} failed: ${err.message}`);
         });
     }
+    // Push to remote relay server (fire-and-forget)
+    if (RELAY_URL && RELAY_PUSH_TOKEN) {
+        fetch(`${RELAY_URL}/push`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${RELAY_PUSH_TOKEN}`,
+            },
+            body: JSON.stringify({ event, data }),
+        }).catch(() => { }); // silent — relay may be down
+    }
 }
 /** Returns the port the SSE server is actively using */
 export function getActivePort() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dalmasonto/taskflow-mcp",
-  "version": "1.0.16",
+  "version": "1.0.18",
   "description": "MCP server for TaskFlow — manage projects, tasks, timers, analytics via AI agents",
   "type": "module",
   "main": "dist/index.js",
@@ -38,6 +38,7 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "latest",
     "better-sqlite3": "latest",
+    "dotenv": "^17.4.1",
     "zod": "latest"
   },
   "devDependencies": {