@dalmasonto/taskflow-mcp 1.0.11 → 1.0.15

package/dist/tools/tasks.js

@@ -202,6 +202,10 @@ export async function updateTask(params) {
         updates.due_date = params.due_date;
     if (params.estimated_time !== undefined)
         updates.estimated_time = params.estimated_time;
+    if (params.allowed_tools !== undefined)
+        updates.allowed_tools = JSON.stringify(params.allowed_tools);
+    if (params.denied_tools !== undefined)
+        updates.denied_tools = JSON.stringify(params.denied_tools);
     if (Object.keys(updates).length === 0) {
         return successResponse(oldParsed);
     }
@@ -356,14 +360,14 @@ export function registerTaskTools(server) {
         links: z.array(LinkSchema).optional(),
         due_date: z.string().optional(),
         estimated_time: z.number().optional(),
-    }, async (params) => createTask(params));
+    }, { readOnlyHint: false }, async (params) => createTask(params));
     server.tool('list_tasks', 'List tasks with optional filters. Use at conversation start to see what is in progress or blocked. Filter by status, project, priority, or tag.', {
         status: TaskStatus.optional(),
         project_id: z.number().optional(),
         priority: TaskPriority.optional(),
         tag: z.string().optional(),
-    }, async (params) => listTasks(params));
-    server.tool('get_task', 'Get a task by ID with time tracking info. Read the description carefully — it often contains implementation details and acceptance criteria.', { id: z.number() }, async (params) => getTask(params));
+    }, { readOnlyHint: true }, async (params) => listTasks(params));
+    server.tool('get_task', 'Get a task by ID with time tracking info. Read the description carefully — it often contains implementation details and acceptance criteria.', { id: z.number() }, { readOnlyHint: true }, async (params) => getTask(params));
     server.tool('update_task', 'Update task fields. Use this to add details, update descriptions with progress notes, or adjust priority as you learn more.', {
         id: z.number(),
         title: z.string().optional(),
@@ -376,12 +380,14 @@ export function registerTaskTools(server) {
         links: z.array(LinkSchema).optional(),
         due_date: z.string().optional(),
         estimated_time: z.number().optional(),
-    }, async (params) => updateTask(params));
+        allowed_tools: z.array(z.string()).optional().describe('Allowlist of MCP tool names for this task. If set, only these tools can be used while timer is active.'),
+        denied_tools: z.array(z.string()).optional().describe('Denylist of MCP tool names for this task. These tools are blocked while timer is active.'),
+    }, { readOnlyHint: false }, async (params) => updateTask(params));
     server.tool('update_task_status', 'Update task status with transition validation. Use when a task becomes blocked, is partially done, or needs to be reopened.', {
         id: z.number(),
         status: TaskStatus,
-    }, async (params) => updateTaskStatus(params));
-    server.tool('delete_task', 'Delete a task by ID. Use sparingly — prefer updating status to "done" instead of deleting.', { id: z.number() }, async (params) => deleteTask(params));
+    }, { readOnlyHint: false }, async (params) => updateTaskStatus(params));
+    server.tool('delete_task', 'Delete a task by ID. Use sparingly — prefer updating status to "done" instead of deleting.', { id: z.number() }, { destructiveHint: true }, async (params) => deleteTask(params));
     server.tool('bulk_create_tasks', 'Create multiple tasks in a single transaction. Useful when breaking down a feature into subtasks.', {
         tasks: z.array(z.object({
             title: z.string(),
@@ -392,6 +398,6 @@ export function registerTaskTools(server) {
             dependencies: z.array(z.number()).optional(),
             tags: z.array(z.string()).optional(),
         })),
-    }, async (params) => bulkCreateTasks(params));
-    server.tool('search_tasks', 'Search tasks by title or description. Use this to find tasks related to your current work before creating duplicates.', { query: z.string() }, async (params) => searchTasks(params));
+    }, { readOnlyHint: false }, async (params) => bulkCreateTasks(params));
+    server.tool('search_tasks', 'Search tasks by title or description. Use this to find tasks related to your current work before creating duplicates.', { query: z.string() }, { readOnlyHint: true }, async (params) => searchTasks(params));
 }

package/dist/tools/terminal.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerTerminalTools(server: McpServer): void;

package/dist/tools/terminal.js

@@ -0,0 +1,73 @@
+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 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') };
+    return { agent };
+}
+export function registerTerminalTools(server) {
+    server.tool('capture_terminal', 'Capture the current terminal content of an agent\'s tmux pane. Returns the visible text on screen. Useful for seeing what prompts or output an agent is displaying.', {
+        agent_name: z.string().describe('Name of the agent whose terminal to capture'),
+    }, { readOnlyHint: true }, async (params) => {
+        const result = getAgentPane(params.agent_name);
+        if (result.error)
+            return result.error;
+        try {
+            const output = execFileSync('tmux', ['capture-pane', '-p', '-t', result.agent.tmux_pane], { timeout: 5000 }).toString();
+            return successResponse({
+                agent: params.agent_name,
+                pane: result.agent.tmux_pane,
+                content: output,
+            });
+        }
+        catch (err) {
+            return errorResponse(`Failed to capture pane: ${err.message}`, 'VALIDATION_ERROR');
+        }
+    });
+    server.tool('send_keys', 'Send raw keystrokes to an agent\'s tmux pane. Use this to respond to interactive prompts (yes/no, numbered choices, permission approvals) displayed in an agent\'s terminal. By default appends Enter after the keys.', {
+        agent_name: z.string().describe('Name of the agent whose terminal to send keys to'),
+        keys: z.string().describe('The keys/text to send (e.g. "yes", "1", "y") or tmux key names (e.g. "Escape", "Up", "Down", "BTab")'),
+        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);
+        if (result.error)
+            return result.error;
+        const sendEnter = params.enter !== false;
+        const isLiteral = params.literal !== false;
+        try {
+            const pane = result.agent.tmux_pane;
+            if (isLiteral) {
+                // Send as literal text (like typing on a keyboard)
+                execFileSync('tmux', ['send-keys', '-t', pane, '-l', params.keys], { stdio: 'ignore', timeout: 5000 });
+                if (sendEnter) {
+                    execFileSync('tmux', ['send-keys', '-t', pane, 'Enter'], { stdio: 'ignore', timeout: 5000 });
+                }
+            }
+            else {
+                // Send as tmux key names (Escape, Up, Down, etc.)
+                const args = ['send-keys', '-t', pane, params.keys];
+                if (sendEnter)
+                    args.push('Enter');
+                execFileSync('tmux', args, { stdio: 'ignore', timeout: 5000 });
+            }
+            logActivity('terminal_send_keys', `Sent keys to ${params.agent_name}: ${params.keys.slice(0, 50)}`, { entityType: 'agent' });
+            return successResponse({
+                agent: params.agent_name,
+                pane: result.agent.tmux_pane,
+                keys: params.keys,
+                enter: sendEnter,
+                sent: true,
+            });
+        }
+        catch (err) {
+            return errorResponse(`Failed to send keys: ${err.message}`, 'VALIDATION_ERROR');
+        }
+    });
+}

package/dist/tools/timer.js

@@ -140,15 +140,15 @@ export async function listSessions(params) {
 }
 // ─── MCP registration ─────────────────────────────────────────────────
 export function registerTimerTools(server) {
-    server.tool('start_timer', 'Start a timer session for a task. Call this before beginning work on any task to track focused time. Automatically transitions the task to "in_progress".', { task_id: z.number() }, async (params) => startTimer(params));
-    server.tool('pause_timer', 'Pause the active timer session for a task. Call when switching context or waiting for user input. The task transitions to "paused".', { task_id: z.number() }, async (params) => pauseTimer(params));
+    server.tool('start_timer', 'Start a timer session for a task. Call this before beginning work on any task to track focused time. Automatically transitions the task to "in_progress".', { task_id: z.number() }, { readOnlyHint: false }, async (params) => startTimer(params));
+    server.tool('pause_timer', 'Pause the active timer session for a task. Call when switching context or waiting for user input. The task transitions to "paused".', { task_id: z.number() }, { readOnlyHint: false }, async (params) => pauseTimer(params));
     server.tool('stop_timer', 'Stop the active timer and set a final status. Call when finishing work — use "done" if complete, "partial_done" if more remains, "blocked" if stuck.', {
         task_id: z.number(),
         final_status: z.enum(['done', 'partial_done', 'blocked']).optional(),
-    }, async (params) => stopTimer(params));
+    }, { readOnlyHint: false }, async (params) => stopTimer(params));
     server.tool('list_sessions', 'List timer sessions with optional filters. Use to review time spent on a task or across a date range.', {
         task_id: z.number().optional(),
         start_date: z.string().optional(),
         end_date: z.string().optional(),
-    }, async (params) => listSessions(params));
+    }, { readOnlyHint: true }, async (params) => listSessions(params));
 }

package/dist/types.d.ts

@@ -22,9 +22,9 @@ export declare const ProjectType: z.ZodEnum<{
 export type ProjectType = z.infer<typeof ProjectType>;
 export declare const NotificationType: z.ZodEnum<{
     info: "info";
+    error: "error";
     success: "success";
     warning: "warning";
-    error: "error";
 }>;
 export type NotificationType = z.infer<typeof NotificationType>;
 export declare const AgentMessageStatus: z.ZodEnum<{
@@ -66,6 +66,10 @@ export declare const ActivityAction: z.ZodEnum<{
     agent_question_answered: "agent_question_answered";
     agent_connected: "agent_connected";
     agent_disconnected: "agent_disconnected";
+    terminal_send_keys: "terminal_send_keys";
+    terminal_captured: "terminal_captured";
+    compaction_summary: "compaction_summary";
+    activity_compacted: "activity_compacted";
 }>;
 export type ActivityAction = z.infer<typeof ActivityAction>;
 export declare const VALID_TRANSITIONS: Record<TaskStatus, TaskStatus[]>;

package/dist/types.js

@@ -16,6 +16,8 @@ export const ActivityAction = z.enum([
     'link_added', 'tag_added', 'tag_removed', 'debug_log',
     'agent_question', 'agent_question_answered',
     'agent_connected', 'agent_disconnected',
+    'terminal_send_keys', 'terminal_captured',
+    'compaction_summary', 'activity_compacted',
 ]);
 export const VALID_TRANSITIONS = {
     not_started: ['in_progress', 'blocked'],

package/package.json

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