@dalmasonto/taskflow-mcp 1.0.17 → 1.0.19

package/dist/agent-registry.js

@@ -57,8 +57,12 @@ export function registerAgent(options) {
     checkAgentLiveness();
     // Find all entries for this project path
     const entries = db.prepare('SELECT * FROM agent_registry WHERE project_path = ? ORDER BY connected_at DESC').all(projectPath);
-    // Priority 1: Reuse a disconnected entry (preserves history)
-    const disconnected = entries.find(e => e.status === 'disconnected');
+    // Priority 1: Reuse a disconnected entry that had the SAME PID (exact session resume)
+    // Priority 2: Reuse any disconnected entry for this path (new session, same project)
+    // This prevents a reconnecting agent from stealing another agent's identity
+    // when two sessions share the same project directory.
+    const disconnected = entries.find(e => e.status === 'disconnected' && e.pid === agentPid)
+        || entries.find(e => e.status === 'disconnected');
     if (disconnected) {
         const newName = options?.customName || disconnected.name;
         const renamed = newName !== disconnected.name;

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,9 +20,18 @@ const DEFAULTS = {
     logLevel: 'info',
     agentLivenessInterval: 30_000,
     maxPortAttempts: 10,
+    relayUrl: '',
+    relayPushToken: '',
 };
 // ─── config file path ────────────────────────────────────────────────
-const CONFIG_PATH = resolve(homedir(), '.taskflow_config.json');
+// Config lives alongside the database in ~/.taskflow/
+// Falls back to legacy ~/.taskflow_config.json for backward compat
+import { existsSync } from 'fs';
+const NEW_CONFIG_PATH = resolve(homedir(), '.taskflow', 'config.json');
+const LEGACY_CONFIG_PATH = resolve(homedir(), '.taskflow_config.json');
+const CONFIG_PATH = existsSync(NEW_CONFIG_PATH) ? NEW_CONFIG_PATH
+    : existsSync(LEGACY_CONFIG_PATH) ? LEGACY_CONFIG_PATH
+        : NEW_CONFIG_PATH; // default to new path for fresh installs
 // ─── loader ──────────────────────────────────────────────────────────
 function loadFromFile() {
     try {
@@ -57,6 +68,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';
@@ -139,8 +140,10 @@ if (!httpOnly) {
     const transport = new StdioServerTransport();
     await server.connect(transport);
     const { registerAgent, unregisterAgent } = await import('./agent-registry.js');
-    // Auto-register this agent
+    const { setAgentName } = await import('./tools/agent-inbox.js');
+    // Auto-register this agent and sync name to agent-inbox tools
     const agentName = registerAgent();
+    setAgentName(agentName);
     const agentPid = process.ppid;
     console.error(`[agent] registered as "${agentName}"`);
     let cleanup = () => { try {

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

@@ -3,8 +3,11 @@ import { execFileSync } from 'child_process';
 import { getDb } from './db.js';
 import { logActivity } from './helpers.js';
 import { getConfig } from './config.js';
+import { validateKeys } from './tools/terminal.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,37 +54,70 @@ 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,
-];
+/**
+ * Detect an active Claude Code permission prompt.
+ *
+ * The definitive marker is "Esc to cancel" which only appears in the
+ * footer of active prompts and disappears once the user responds.
+ * We check only the last 10 lines of the VISIBLE screen (not full
+ * scrollback) to avoid matching old, already-answered prompts.
+ *
+ * Generic patterns like "Do you want to" and "(y/n)" are intentionally
+ * excluded — Claude writes these in prose responses too, causing false flags.
+ */
 function detectPrompt(content) {
-    const tail = content.split('\n').slice(-25).join('\n');
+    // Only check last 10 lines — the prompt footer is always at the bottom
+    const lines = content.split('\n');
+    const tail = lines.slice(-10).join('\n');
     const hints = [];
-    if (/Esc to cancel/i.test(tail))
+    const hasEsc = /Esc to cancel/i.test(tail);
+    const hasTab = /Tab to amend/i.test(tail);
+    if (hasEsc)
         hints.push('Esc to cancel');
-    if (/Tab to amend/i.test(tail))
+    if (hasTab)
         hints.push('Tab to amend');
     if (/shift\+tab/i.test(tail))
         hints.push('Shift+Tab');
-    const detected = PROMPT_PATTERNS.some(p => p.test(tail));
+    // Only flag as detected if we see the actual prompt footer
+    const detected = hasEsc || hasTab;
     return { detected, hints };
 }
-function pollAgentPrompts(prevState) {
+/** 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 output = execFileSync('tmux', ['capture-pane', '-p', '-S', '-', '-t', agent.tmux_pane], { timeout: 5000 }).toString();
-            const { detected, hints } = detectPrompt(output);
-            const wasAwaiting = prevState.get(agent.name) ?? false;
+            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) {
-                // Transition: not awaiting → awaiting — fire notification + broadcast
-                prevState.set(agent.name, true);
+                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);
@@ -90,8 +126,7 @@ function pollAgentPrompts(prevState) {
                 broadcast('agent_awaiting_input', { entity: 'agent', action: 'agent_awaiting_input', payload: { name: agent.name, hints, awaiting: true } });
             }
             else if (!detected && wasAwaiting) {
-                // Transition: awaiting → resolved
-                prevState.set(agent.name, false);
+                promptState.set(agent.name, false);
                 broadcast('agent_input_resolved', { entity: 'agent', action: 'agent_input_resolved', payload: { name: agent.name, awaiting: false } });
             }
         }
@@ -100,9 +135,10 @@ function pollAgentPrompts(prevState) {
         }
     }
     // Clean up agents that disconnected
-    for (const [name] of prevState) {
+    for (const [name] of promptState) {
         if (!agents.some(a => a.name === name)) {
-            prevState.delete(name);
+            promptState.delete(name);
+            contentHashes.delete(name);
         }
     }
 }
@@ -439,6 +475,10 @@ export async function startSSEServer() {
                 jsonResponse(res, 400, { error: `Agent "${agentName}" has no tmux pane` });
                 return;
             }
+            if (agent.status !== 'connected') {
+                jsonResponse(res, 403, { error: `Agent "${agentName}" is disconnected — sending keys to a bare shell is blocked for security` });
+                return;
+            }
             let body;
             try {
                 body = JSON.parse(await readBody(req));
@@ -454,6 +494,12 @@ export async function startSSEServer() {
                 jsonResponse(res, 400, { error: 'keys must be a string' });
                 return;
             }
+            // Block shell escape patterns and oversized payloads
+            const violation = validateKeys(keys);
+            if (violation) {
+                jsonResponse(res, 403, { error: violation });
+                return;
+            }
             try {
                 const pane = agent.tmux_pane;
                 if (literal) {
@@ -530,20 +576,43 @@ export async function startSSEServer() {
                         }
                     }
                 }, 30_000);
-                // Prompt detection — poll connected agents for input-required state
+                // Terminal capture & prompt detection — single capture loop for all agents
                 const promptState = new Map();
+                const contentHashes = new Map();
                 setInterval(() => {
                     try {
-                        pollAgentPrompts(promptState);
+                        pollAgentTerminals(promptState, contentHashes);
                     }
                     catch { /* ignore */ }
-                }, 5_000);
+                }, 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(async (res) => {
+                        if (res.ok) {
+                            console.log(`[SSE] registered with relay at ${RELAY_URL}`);
+                        }
+                        else {
+                            const body = await res.text().catch(() => '');
+                            console.error(`[SSE] relay registration rejected: ${res.status} ${body}`);
+                        }
+                    }).catch((err) => {
+                        console.error(`[SSE] relay registration failed: ${err.message}`);
+                    });
+                }
                 resolve();
             });
         }
@@ -567,6 +636,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) {
@@ -583,6 +653,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/dist/tools/agent-inbox.d.ts

@@ -1,5 +1,10 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 /** The name assigned to this agent after registration */
 declare let myAgentName: string | null;
+/** Set the agent name from external registration (index.ts).
+ *  This prevents double-registration when index.ts registers at startup
+ *  and ensureRegistered() would register again on first tool call.
+ */
+export declare function setAgentName(name: string): void;
 export { myAgentName };
 export declare function registerAgentInboxTools(server: McpServer): void;

package/dist/tools/agent-inbox.js

@@ -4,11 +4,28 @@ import { logActivity, errorResponse, successResponse, now, broadcastChange } fro
 import { registerAgent as doRegister, getAgent, listAgents } from '../agent-registry.js';
 /** The name assigned to this agent after registration */
 let myAgentName = null;
-/** Get or auto-register the agent name */
+/** Set the agent name from external registration (index.ts).
+ *  This prevents double-registration when index.ts registers at startup
+ *  and ensureRegistered() would register again on first tool call.
+ */
+export function setAgentName(name) {
+    myAgentName = name;
+}
+/** Get or auto-register the agent name.
+ *  Verifies the cached registration is still valid — if the liveness
+ *  checker disconnected us while sleeping, re-register to reclaim identity.
+ */
 function ensureRegistered() {
-    if (!myAgentName) {
-        myAgentName = doRegister();
+    if (myAgentName) {
+        // Verify our registration is still active
+        const agent = getAgent(myAgentName);
+        if (agent && agent.status === 'connected' && agent.pid === process.ppid) {
+            return myAgentName;
+        }
+        // Stale — re-register
+        myAgentName = null;
     }
+    myAgentName = doRegister();
     return myAgentName;
 }
 export { myAgentName };

package/dist/tools/terminal.d.ts

@@ -1,2 +1,4 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+/** Validate keys before sending — blocks shell escape patterns */
+export declare function validateKeys(keys: string): string | null;
 export declare function registerTerminalTools(server: McpServer): void;

package/dist/tools/terminal.js

@@ -2,13 +2,34 @@ import { z } from 'zod';
 import { execFileSync } from 'child_process';
 import { getDb } from '../db.js';
 import { logActivity, errorResponse, successResponse } from '../helpers.js';
-function getAgentPane(agentName) {
+const MAX_KEYS_LENGTH = 200;
+// Patterns that should never be sent via remote key injection
+const BLOCKED_PATTERNS = [
+    /^\s*!/, // Claude Code shell escape (! command)
+    /;\s*!/, // shell escape after semicolon
+];
+/** Validate keys before sending — blocks shell escape patterns */
+export function validateKeys(keys) {
+    if (keys.length > MAX_KEYS_LENGTH) {
+        return `Keys too long (${keys.length} chars, max ${MAX_KEYS_LENGTH}) — potential injection`;
+    }
+    for (const pattern of BLOCKED_PATTERNS) {
+        if (pattern.test(keys)) {
+            return 'Blocked: shell escape pattern detected (! prefix). Use the terminal directly for shell commands.';
+        }
+    }
+    return null; // valid
+}
+function getAgentPane(agentName, requireConnected = false) {
     const db = getDb();
     const agent = db.prepare('SELECT * FROM agent_registry WHERE name = ?').get(agentName);
     if (!agent)
         return { error: errorResponse(`Agent "${agentName}" not found`, 'NOT_FOUND') };
     if (!agent.tmux_pane)
         return { error: errorResponse(`Agent "${agentName}" has no tmux pane`, 'VALIDATION_ERROR') };
+    if (requireConnected && agent.status !== 'connected') {
+        return { error: errorResponse(`Agent "${agentName}" is disconnected — sending keys to a bare shell is blocked for security`, 'VALIDATION_ERROR') };
+    }
     return { agent };
 }
 export function registerTerminalTools(server) {
@@ -36,9 +57,13 @@ export function registerTerminalTools(server) {
         enter: z.boolean().optional().describe('Whether to press Enter after the keys (default: true)'),
         literal: z.boolean().optional().describe('Send as literal text with -l flag (default: true). Set false for tmux key names like Escape, Up, Down, Left, Right, BTab'),
     }, { destructiveHint: true }, async (params) => {
-        const result = getAgentPane(params.agent_name);
+        const result = getAgentPane(params.agent_name, true);
         if (result.error)
             return result.error;
+        // Validate keys for injection attacks
+        const violation = validateKeys(params.keys);
+        if (violation)
+            return errorResponse(violation, 'VALIDATION_ERROR');
         const sendEnter = params.enter !== false;
         const isLiteral = params.literal !== false;
         try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dalmasonto/taskflow-mcp",
-  "version": "1.0.17",
+  "version": "1.0.19",
   "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": {